!pip install pandas matplotlib numpy scipy

Requirement already satisfied: pandas in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (2.2.3)
Requirement already satisfied: matplotlib in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (3.10.3)
Requirement already satisfied: numpy in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (2.2.5)
Requirement already satisfied: scipy in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (1.15.3)
Requirement already satisfied: python-dateutil>=2.8.2 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from pandas) (2.9.0.post0)
Requirement already satisfied: pytz>=2020.1 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from pandas) (2025.2)
Requirement already satisfied: tzdata>=2022.7 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from pandas) (2025.2)
Requirement already satisfied: contourpy>=1.0.1 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (1.3.2)
Requirement already satisfied: cycler>=0.10 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (0.12.1)
Requirement already satisfied: fonttools>=4.22.0 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (4.58.0)
Requirement already satisfied: kiwisolver>=1.3.1 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (1.4.8)
Requirement already satisfied: packaging>=20.0 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (25.0)
Requirement already satisfied: pillow>=8 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (11.2.1)
Requirement already satisfied: pyparsing>=2.3.1 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from matplotlib) (3.2.3)
Requirement already satisfied: six>=1.5 in c:\users\hdyec\appdata\local\programs\python\python313\lib\site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)

[notice] A new release of pip is available: 25.1.1 -> 25.2
[notice] To update, run: python.exe -m pip install --upgrade pip

# Import all required libraries
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import random
from math import factorial
from scipy import stats as st
from scipy.stats import norm
import math as mt

# Load the dataset
games = pd.read_csv(r'C:\Users\hdyec\OneDrive\Documents\Project_5_Jupyter_Notebook\games (1).csv')

# Display basic information about the dataset
display(games.head())

# Check for duplicate entries
games.duplicated().sum()

np.int64(0)

#Check for missing entries
games.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16715 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   Name             16713 non-null  object 
 1   Platform         16715 non-null  object 
 2   Year_of_Release  16446 non-null  float64
 3   Genre            16713 non-null  object 
 4   NA_sales         16715 non-null  float64
 5   EU_sales         16715 non-null  float64
 6   JP_sales         16715 non-null  float64
 7   Other_sales      16715 non-null  float64
 8   Critic_Score     8137 non-null   float64
 9   User_Score       10014 non-null  object 
 10  Rating           9949 non-null   object 
dtypes: float64(6), object(5)
memory usage: 1.4+ MB

# Convert column names to lowercase
games.columns = games.columns.str.lower()

# Verify the changes
display(games.head())

# Check current data types
games.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16715 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16713 non-null  object 
 1   platform         16715 non-null  object 
 2   year_of_release  16446 non-null  float64
 3   genre            16713 non-null  object 
 4   na_sales         16715 non-null  float64
 5   eu_sales         16715 non-null  float64
 6   jp_sales         16715 non-null  float64
 7   other_sales      16715 non-null  float64
 8   critic_score     8137 non-null   float64
 9   user_score       10014 non-null  object 
 10  rating           9949 non-null   object 
dtypes: float64(6), object(5)
memory usage: 1.4+ MB

#Make games user_score a float
games['user_score'] = pd.to_numeric(games['user_score'], errors='coerce')
games['user_score'] = games['user_score'].astype(float)

games.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16715 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16713 non-null  object 
 1   platform         16715 non-null  object 
 2   year_of_release  16446 non-null  float64
 3   genre            16713 non-null  object 
 4   na_sales         16715 non-null  float64
 5   eu_sales         16715 non-null  float64
 6   jp_sales         16715 non-null  float64
 7   other_sales      16715 non-null  float64
 8   critic_score     8137 non-null   float64
 9   user_score       7590 non-null   float64
 10  rating           9949 non-null   object 
dtypes: float64(7), object(4)
memory usage: 1.4+ MB

#Multiply user_score by 10 to match with critic_score

games['user_score'] = games['user_score'] * 10

display(games)

# Look at NaN values in critic_score
games[games['critic_score'].isna()]

# Examine missing values
games.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16715 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16713 non-null  object 
 1   platform         16715 non-null  object 
 2   year_of_release  16446 non-null  float64
 3   genre            16713 non-null  object 
 4   na_sales         16715 non-null  float64
 5   eu_sales         16715 non-null  float64
 6   jp_sales         16715 non-null  float64
 7   other_sales      16715 non-null  float64
 8   critic_score     8137 non-null   float64
 9   user_score       7590 non-null   float64
 10  rating           9949 non-null   object 
dtypes: float64(7), object(4)
memory usage: 1.4+ MB

# Calculate percentage of missing values (2)
missing_name = 2/16715 * 100
display(missing_name)

# year_of_release (269)
missing_year_of_release = 269/16715 * 100
display(missing_year_of_release)

# Genre is missing the same amount as the name column (2)
display(missing_name)

# critic_score (8,578) 
missing_critic = 8578/16715 * 100
display(missing_critic)


#user_score 
missing_user = 9125/16715 * 100
display(missing_user)


#rating (6,766)
missing_rating = 6766/16715 * 100
display(missing_rating)


# platform is not missing any value
# na_sales is not missing any values
# eu_sales is not missing any values
# jp_sales is not missing any values
# other_sales is not missing any values

0.011965300628178284

1.609332934489979

0.011965300628178284

51.31917439425665

54.59168411606342

40.478612025127134

#Analyze patterns in missing values

# View the missing values for year_of_release
display(games[games['year_of_release'].isna()].head(20))

# how many unique names are in this dataset since we saw multiple Sonic the Hedgehog titles
display(games['name'].nunique())


#Create new titles for ease and memory retention
LEGO_1 = "LEGO Batman: The Videogame"
LEGO_2 = "LEGO Indiana Jones: The Original Adventures"
LEGO_3 = "LEGO Harry Potter: Years 5-7"

#Display the data we are going to be working with
display(games[(games['name'] == LEGO_1) | (games['name'] == LEGO_2) | (games['name'] == LEGO_3)])

11559

# Batman and Indiana Jones - 2008 and Harry Potter - 2012
#Reminder:
# LEGO_1 = "LEGO Batman: The Videogame"
# LEGO_2 = "LEGO Indiana Jones: The Original Adventures"
# LEGO_3 = "LEGO Harry Potter: Years 5-7"


#Create a boolean mask for the 0 values in year_of_release as it pertains to LEGO_1 and LEGO_2 titles
mask = (((games['name'] == LEGO_1) | (games['name'] == LEGO_2)) & (games['year_of_release'].isna()))

#Input 2008 into the specified titles using mask and the column 'year_of_release'
games.loc[mask, 'year_of_release'] = 2008


#Test to see if 2008 replaced the NaN
display(games[(games['name'] == LEGO_1) | (games['name'] == LEGO_2)])

#Test to see if the other values were filled in (they are not which is a good thing)
display(games[games['year_of_release'].isna()].head(10))

#Reminder:
# LEGO_1 = "LEGO Batman: The Videogame"
# LEGO_2 = "LEGO Indiana Jones: The Original Adventures"
# LEGO_3 = "LEGO Harry Potter: Years 5-7" (2012)

display(games[games['name'] == LEGO_3])

#Create a boolean mask
mask_1 = (games['name'] == LEGO_3) & (games['year_of_release'].isna())

#Input the mask into the original DF
games.loc[mask_1, 'year_of_release'] = 2012

#Display the new data
display(games[games['name'] == LEGO_3])

# Look at the NaN values for year_of_release
display(games[games['year_of_release'].isna()])

# data is float dtype
games.info()

# Create a mask for the known years by dropping the NaN values in the year_of_release column
known_years = games.dropna(subset=['year_of_release'])
display(known_years)

#Define a mode function to get the mode of the subset of the year_of_release columns by name
def mode(series):
    mode_result = series.mode() # This returns a Series
    if not mode_result.empty:
        return mode_result.iloc[0] # .iloc[0] is similar to [0] for a Series
    else:
        return np.nan

#Explaining the if not statement: reads as "if mode_result is not empty."
#This condition will be True if mode_result contains one or more modes.
#This condition will be False if mode_result is an empty Series (meaning no mode was found).
#If the condition is true the code runs the next line: return mode_result.iloc[0] 
#If the mode result is not empty, this will return the first mode value of the True condition


#Group the known years by the games name to produce the year that games was released as a series and apply your function mode
known_years_series = known_years.groupby('name')['year_of_release'].apply(mode)
display(known_years_series)

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16715 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16713 non-null  object 
 1   platform         16715 non-null  object 
 2   year_of_release  16456 non-null  float64
 3   genre            16713 non-null  object 
 4   na_sales         16715 non-null  float64
 5   eu_sales         16715 non-null  float64
 6   jp_sales         16715 non-null  float64
 7   other_sales      16715 non-null  float64
 8   critic_score     8137 non-null   float64
 9   user_score       7590 non-null   float64
 10  rating           9949 non-null   object 
dtypes: float64(7), object(4)
memory usage: 1.4+ MB

name
 Beyblade Burst                 2016.0
 Fire Emblem Fates              2015.0
 Frozen: Olaf's Quest           2013.0
 Haikyu!! Cross Team Match!     2016.0
 Tales of Xillia 2              2012.0
                                 ...  
thinkSMART FAMILY!              2010.0
thinkSMART: Chess for Kids      2011.0
uDraw Studio                    2010.0
uDraw Studio: Instant Artist    2011.0
¡Shin Chan Flipa en colores!    2007.0
Name: year_of_release, Length: 11426, dtype: float64

#Convert the Series to a dictionary
known_years_dict = known_years_series.to_dict()

#The dictionary lists out all of the title names and associated years, the information is abundant so we will not display the info

#Create a DataFrame with the known_years_dict
known_years_df = pd.DataFrame(list(known_years_dict.items()), columns = ['name','year_of_release'])
display(known_years_df)

#Merge the new DF with the original DF using a left merge to merge the information on the original DF        
games_merged = games.merge(known_years_df, on='name', how='left')
display(games_merged)

#fill the NaN values using .fillna() and putting the newly added column into the original year_of_release column
games_merged['year_of_release_x'] = games_merged['year_of_release_x'].fillna(games_merged['year_of_release_y'])
display(games_merged)

#Now, you can drop the new column since it's no longer needed
games_merged = games_merged.drop(columns=['year_of_release_y'])
display(games_merged)

#Check if this worked - we see the missing Madden game year was filled in correctly
display(games_merged[games_merged['name'] == 'Madden NFL 2004'])
display(games_merged[games_merged['name'] == 'Sonic the Hedgehog'])

#return the column back to year_of_release without the suffix
games['year_of_release'] = games_merged['year_of_release_x']
display(games)

# See how many NaN values you now have (146)
display(games[games['year_of_release'].isna()])

# Perform the exact same thing on the 'rating' column

known_ratings = games.dropna(subset=['rating'])
display(known_ratings)

known_ratings_series = known_ratings.groupby('name')['rating'].apply(mode)
display(known_ratings_series)

#Convert the Series to a dictionary
known_ratings_dict = known_ratings_series.to_dict()

#The dictionary lists out all of the title names and associated years, the information is abundant so we will not display the info

#Create a DataFrame with the known_years_dict
known_ratings_df = pd.DataFrame(list(known_ratings_dict.items()), columns = ['name','rating'])
display(known_ratings_df)

#Merge the new DF with the original DF using a left merge to merge the information on the original DF        
games_merged = games.merge(known_ratings_df, on='name', how='left')
display(games_merged)

#fill the NaN values using .fillna() and putting the newly added column into the original year_of_release column
games_merged['rating_x'] = games_merged['rating_x'].fillna(games_merged['rating_y'])
display(games_merged)

#Now, you can drop the new column since it's no longer needed
games_merged = games_merged.drop(columns=['rating_y'])
display(games_merged)

#Check if this worked - we see the missing Madden game year was filled in correctly
display(games_merged[games_merged['name'] == 'Madden NFL 2004'])
display(games_merged[games_merged['name'] == 'Sonic the Hedgehog'])

#We see that the missing Sonic the Hedgehog game was replaced with E10+

#return the column back to rating without the suffix
games['rating'] = games_merged['rating_x']
display(games)

# See how many NaN values you now have ()
display(games[games['rating'].isna()])

name
 Tales of Xillia 2              T
.hack//Infection Part 1         T
.hack//Mutation Part 2          T
.hack//Outbreak Part 3          T
007 Racing                      T
                               ..
thinkSMART                      E
thinkSMART FAMILY!              E
thinkSMART: Chess for Kids      E
uDraw Studio                    E
uDraw Studio: Instant Artist    E
Name: rating, Length: 6066, dtype: object

# Look at duplicated titles

display(games[games[['name','platform','year_of_release']].duplicated()])

display(games[games['name'] == 'Need for Speed: Most Wanted'])

display(games[games['name'] == 'Sonic the Hedgehog'])

display(games[games['name'] == 'Madden NFL 13'])

# Analyze patterns in missing values
# View the missing names
display(games[games['name'].isna()])

# We also found the 2 missing genre's; looks look a little deeper; find other games from 1993 on the GEN platform
display(games[(games['year_of_release'] == 1993) & (games['platform'] == 'GEN')])

#It's still hard to determine what these games may be

# Let's check if they are duplicates
display(games[games['na_sales'] == 1.78])
display(games[games['eu_sales'] == 0.53])
display(games[games['jp_sales'] == 0.03])
display(games[games['other_sales'] == 0.08])

display(games[(games['jp_sales'] == 0.03) & (games['platform'] == 'GEN')])

#This did not help too much 

#How many GEN are there? How many games were released in 1993?
display(games[games['platform'] == 'GEN'])

#The closest game to the second NaN is Puzzle & Action: Tant-R	released in 1994

#How many games were released in 1993?
display(games[games['year_of_release'] == 1993])

#There were 62, but this still does not help much 


#A quick google search stated that Sonic the Hedgehog made those sames of the first NaN value, but this shows differently
display(games[games['name'] == 'Sonic the Hedgehog'])

# Since we are not able to figure out what these titles are, we will drop them as 2 will not change the data drastically.
#First, drop the 2 rows with the missing name and genre 
games.dropna(subset = ['name'], inplace = True)

#Test it
display(games[games['name'].isna()])
games.info()


# Drop the duplicated titles that also have the same platform and year_of_release (this also gets rid of 1 of the NaN 'name' and 'genre'
#column; this is fine we will end up getting rid of the other missing NaN 
#games.drop_duplicates(subset=['name', 'platform','year_of_release'], keep=first, inplace=True)

display(games[games[['name','platform','year_of_release']].duplicated()])

games.drop_duplicates(subset = ['name','platform','year_of_release'],keep= 'first', inplace = True)


#Test it
display(games[games['name'] == 'Sonic the Hedgehog'])
display(games[games['name'] == 'Madden NFL 13'])
games.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16713 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16713 non-null  object 
 1   platform         16713 non-null  object 
 2   year_of_release  16567 non-null  float64
 3   genre            16713 non-null  object 
 4   na_sales         16713 non-null  float64
 5   eu_sales         16713 non-null  float64
 6   jp_sales         16713 non-null  float64
 7   other_sales      16713 non-null  float64
 8   critic_score     8137 non-null   float64
 9   user_score       7590 non-null   float64
 10  rating           10386 non-null  object 
dtypes: float64(7), object(4)
memory usage: 1.5+ MB

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16711 non-null  object 
 1   platform         16711 non-null  object 
 2   year_of_release  16565 non-null  float64
 3   genre            16711 non-null  object 
 4   na_sales         16711 non-null  float64
 5   eu_sales         16711 non-null  float64
 6   jp_sales         16711 non-null  float64
 7   other_sales      16711 non-null  float64
 8   critic_score     8135 non-null   float64
 9   user_score       7588 non-null   float64
 10  rating           10384 non-null  object 
dtypes: float64(7), object(4)
memory usage: 1.5+ MB

display(games['user_score'].min() ,games['user_score'].max())
display(games['critic_score'].min(),games['critic_score'].max())

np.float64(0.0)

np.float64(97.0)

np.float64(13.0)

np.float64(98.0)

#Copy the games data to games_1 so we can perform calculations on both DF's to see the difference later
games_1 = games.copy()

#Re-examine the data
games.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16711 non-null  object 
 1   platform         16711 non-null  object 
 2   year_of_release  16565 non-null  float64
 3   genre            16711 non-null  object 
 4   na_sales         16711 non-null  float64
 5   eu_sales         16711 non-null  float64
 6   jp_sales         16711 non-null  float64
 7   other_sales      16711 non-null  float64
 8   critic_score     8135 non-null   float64
 9   user_score       7588 non-null   float64
 10  rating           10384 non-null  object 
dtypes: float64(7), object(4)
memory usage: 1.5+ MB

# Calculate total sales across all regions and put them in a different column

games['total_sales'] = games['na_sales'] + games['eu_sales'] + games['jp_sales'] + games['other_sales']
games_1['total_sales'] = games['na_sales'] + games['eu_sales'] + games['jp_sales'] + games['other_sales']

display(games)

games.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 12 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16711 non-null  object 
 1   platform         16711 non-null  object 
 2   year_of_release  16565 non-null  float64
 3   genre            16711 non-null  object 
 4   na_sales         16711 non-null  float64
 5   eu_sales         16711 non-null  float64
 6   jp_sales         16711 non-null  float64
 7   other_sales      16711 non-null  float64
 8   critic_score     8135 non-null   float64
 9   user_score       7588 non-null   float64
 10  rating           10384 non-null  object 
 11  total_sales      16711 non-null  float64
dtypes: float64(8), object(4)
memory usage: 1.7+ MB

#Group your user_score and critic score into categories of no score, low, medium, high, and very high, and NaN



def score_group(score):
    if score == 0:
        return 'no score'
    elif score < 65:
        return 'low'
    elif score <= 75:
        return 'medium'
    elif score <= 85:
        return 'high'
    elif score > 85:
        return 'very high'
    else:
        return np.nan


#Use apply to apply the function
games_1['critic_score_group'] = games_1['critic_score'].apply(score_group)
games_1['user_score_group'] = games_1['user_score'].apply(score_group)


# See the results
display(games_1)

# Look at the changes
games_1.info()

# Only 1 has no score
display(games_1[games_1['user_score_group'] == "no score"])

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 14 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10384 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8135 non-null   object 
 13  user_score_group    7588 non-null   object 
dtypes: float64(8), object(6)
memory usage: 1.9+ MB

# < 50,000
games_1[(games_1['total_sales'] >= 0) & (games_1['total_sales'] < 0.05)]
#1021

# 50,000 - < 100,000
games_1[(games_1['total_sales'] >= 0.05) & (games_1['total_sales'] < 0.1)]
#1207

# 100,000 - < 200,000
games_1[(games_1['total_sales'] >= 0.1) & (games_1['total_sales'] < 0.2)]
#1481

# 200,000 - < 500,000
games_1[(games_1['total_sales'] >= 0.2) & (games_1['total_sales'] < 0.5)]
#1976

# 500,000 - < 1,000,000
games_1[(games_1['total_sales'] >= 0.5) & (games_1['total_sales'] < 1)]
#1231

# 1,000,000 - < 2,000,000
games_1[(games_1['total_sales'] >= 1) & (games_1['total_sales'] < 2)]
#777

# 2,000,000 - < 3,000,000
games_1[(games_1['total_sales'] >= 2) & (games_1['total_sales'] < 3)]
#245

# 3,000,000 - < 4,000,000
games_1[(games_1['total_sales'] >= 3) & (games_1['total_sales'] < 4)]
#121

# 4,000,000 - < 5,000,000
games_1[(games_1['total_sales'] >= 4) & (games_1['total_sales'] < 5)]
#62

# 5,000,000 - < 10,000,000
games_1[(games_1['total_sales'] >= 5) & (games_1['total_sales'] < 10)]
#105

# 10,000,000 - < 20,000,000
games_1[(games_1['total_sales'] >= 10) & (games_1['total_sales'] < 20)]
#27

# 20,000,000 - < 50,000,000
games_1[(games_1['total_sales'] >= 20) & (games_1['total_sales'] < 50)]
#12

# > 50,000,000
games_1[games_1['total_sales'] >= 50] 
#1


#Group the total sales by their numbers

def total_sales_group(total_sales):
    if total_sales == 0:
        return "No Sale"
    elif total_sales < 0.05:
        return "< 50,000"
    elif total_sales < 0.1:
        return "50,000 - < 100,000"
    elif total_sales < 0.2:
        return "100,000 - < 200,000"
    elif total_sales < 0.5:
        return "200,000 - < 500,000"
    elif total_sales < 1:
        return "500,000 - < 1 million"
    elif total_sales < 5:
        return "1 million - < 5 million"
    elif total_sales < 10:
        return "5 million - < 10 million"
    elif total_sales >= 10:
        return "10 million +"
    else:
        return np.nan

#Use apply()
games_1['total_sales_group'] = games_1['total_sales'].apply(total_sales_group)

#Display the data
display(games_1)

#There are 2 with no sales
games_1[games_1['total_sales_group'] == "No Sale"]

# "< 50,000"
# "50,000 - < 100,000"
# "100,000 - < 200,000"
# "200,000 - < 500,000"
# "500,000 - < 1 million"
# "1 million - < 5 million"
# "5 million - < 10 million"
# "10 million +"

#Create a mask where critic_score and user_score are both NaN and released in 2016
mask = (games_1['user_score_group'].isna()) & (games_1['critic_score_group'].isna()) & (games_1['year_of_release'] >= 2016)
display(mask)

#Name the NaN values previously defined as tbd since these games were just released
games_1.loc[mask,['critic_score_group','user_score_group']] = 'tbd'

#There are 235 rows now marked as tbd
display(games_1[games_1['critic_score_group'] == 'tbd'])

0        False
1        False
2        False
3        False
4        False
         ...  
16710     True
16711    False
16712     True
16713    False
16714     True
Length: 16711, dtype: bool

# 1980 - 2016
display(games_1['year_of_release'].min(), games_1['year_of_release'].max())

# 3,292 video games had a total_sale of less than 50,000 USD
display(games_1[games_1['total_sales_group'] == "< 50,000"])

# 71.26
display(games_1['user_score'].mean())

#68.97
display(games_1['critic_score'].mean())

# 235 rows labeled as 'tbd'
games_1[(games_1['user_score_group'] == "tbd") & (games_1['critic_score_group'] == "tbd")]

np.float64(1980.0)

np.float64(2016.0)

np.float64(71.2565893516078)

np.float64(68.96914566687154)

#Categorize by year

def era_group(year):
    if year < 1990:
        return "80's"
    elif year < 2000:
        return "90's"
    elif year < 2010:
        return "2000's"
    elif year >= 2010:
        return "2010's"
    else:
        np.nan

#Use apply()
games_1['era'] = games_1['year_of_release'].apply(era_group)

display(games_1)

display(games_1)


# Make a copy of this data to use in later calculations if necessary
games_2 = games_1.copy()

#rounded the data
games_1['user_score'] = games_1['user_score'].round(decimals = 1)
games_1['critic_score'] = games_1['critic_score'].round(decimals = 1)

games_2['user_score'] = games_2['user_score'].round(decimals = 1)
games_2['critic_score'] = games_2['critic_score'].round(decimals = 1)

display(games_1)

games_1.info()

#6327 NaN `rating`
games_1[games_1['rating'].isna()]

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10384 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB

#Examine all DF's
games.info()
games_1.info()
games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 12 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16711 non-null  object 
 1   platform         16711 non-null  object 
 2   year_of_release  16565 non-null  float64
 3   genre            16711 non-null  object 
 4   na_sales         16711 non-null  float64
 5   eu_sales         16711 non-null  float64
 6   jp_sales         16711 non-null  float64
 7   other_sales      16711 non-null  float64
 8   critic_score     8135 non-null   float64
 9   user_score       7588 non-null   float64
 10  rating           10384 non-null  object 
 11  total_sales      16711 non-null  float64
dtypes: float64(8), object(4)
memory usage: 1.7+ MB
<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10384 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB
<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10384 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB

# Examine all DF's again
games.info()

games_1.info()

games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 12 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16711 non-null  object 
 1   platform         16711 non-null  object 
 2   year_of_release  16565 non-null  float64
 3   genre            16711 non-null  object 
 4   na_sales         16711 non-null  float64
 5   eu_sales         16711 non-null  float64
 6   jp_sales         16711 non-null  float64
 7   other_sales      16711 non-null  float64
 8   critic_score     8135 non-null   float64
 9   user_score       7588 non-null   float64
 10  rating           10384 non-null  object 
 11  total_sales      16711 non-null  float64
dtypes: float64(8), object(4)
memory usage: 1.7+ MB
<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10384 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB
<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10384 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB

#What are the unique values of `rating`
games_1['rating'].unique()

array(['E', nan, 'M', 'T', 'E10+', 'K-A', 'AO', 'EC', 'RP'], dtype=object)

#First, let's get a count of the values
display(games['rating'].value_counts().sort_index())

rating
AO         1
E       4152
E10+    1470
EC        10
K-A        4
M       1654
RP         3
T       3090
Name: count, dtype: int64

#This line is used to look at specific titles
games_1[games_1['name'] == "WRC: FIA World Rally Championship"]

#Look at the least significant ratings
games_1[(games_1['rating'] == 'AO') | (games_1['rating'] == 'RP') | (games_1['rating'] == 'K-A') | (games_1['rating'] == 'EC')]


#Plan:
# Revert K-A games to E 
# Revert AO to M 
# EC is for very young children, but there was a slight pattern, a few were only available on the DS and between 2005 and 2011;
    # also had mostly Misc genres
# Decide weather to drop or look for games that are ONLY on a PC an revert those from NaN to RP


games_1[games_1['rating'] == 'AO']

# Revert K-A games to E 


#Create a mask:
ka_mask = games_1['rating'] == 'K-A'
ka2_mask = games_2['rating'] == 'K-A'

#use loc[] to change K-A directly to E
games_1.loc[ka_mask,['rating']] = 'E'
games_2.loc[ka2_mask,['rating']] = 'E'

#Check
games_1[games_1['rating'] == 'K-A']
games_2[games_2['rating'] == 'K-A']

# Check to ensure it changed
display(games_1[games_1['name'] == "Worms 2"])
games_2[games_2['name'] == "Worms 2"]

#Revert AO to M

#Create a mask
ao_mask = games_1['rating'] == 'AO'
ao2_mask = games_2['rating'] == 'AO'

#Use loc[] to change this directly
games_1.loc[ao_mask,['rating']] = 'M'
games_2.loc[ao2_mask,['rating']] = 'M'

#Check
display(games_1[games_1['name'] == "Grand Theft Auto: San Andreas"])
display(games_2[games_2['name'] == "Grand Theft Auto: San Andreas"])

# EC is for very young children, but there was a slight pattern, a few were only available on the DS and between 2005 and 2011;
    # also had mostly Misc genres

# Look at EC data under conditions

display(games_1[(games_1['rating'].isna()) & (games_1['platform'] == 'DS') & (games_1['genre'] == 'Misc') 
    & (games_1['name'] != 'Yu-Gi-Oh! GX: Spirit Caller (American Sales)')])



#All of this data looks like its for small children based off of the titles that imply learning for young children with the exception of 
#Yugi-Yo

#Create a mask
ec_mask = (games_1['rating'].isna()) & (games_1['platform'] == 'DS') & (games_1['genre'] == 'Misc') & (games_1['name'] != 'Yu-Gi-Oh! GX: Spirit Caller (American Sales)')
ec2_mask = (games_2['rating'].isna()) & (games_2['platform'] == 'DS') & (games_2['genre'] == 'Misc') & (games_2['name'] != 'Yu-Gi-Oh! GX: Spirit Caller (American Sales)')

games_1.loc[ec_mask, ['rating']] = 'EC'
games_2.loc[ec2_mask, ['rating']] = 'EC'

display(games_1[(games_1['rating'].isna()) & (games_1['platform'] == 'DS') & (games_1['genre'] == 'Misc') 
    & (games_1['name'] != 'Yu-Gi-Oh! GX: Spirit Caller (American Sales)')])

# Change RP games to respective ratings based off of research

display(games_1[games_1['rating'] == 'RP'])


rp_mask = (games_1['name'] == 'Clockwork Empires')
rp_mask_1 = (games_1['name'] == 'Supreme Ruler: Cold War')
rp_mask_2 = (games_1['name'] == 'WRC: FIA World Rally Championship')

#Input the data
games_1.loc[rp_mask,['rating']] = 'T'
games_1.loc[rp_mask_1,['rating']] = 'E10+'
games_1.loc[rp_mask_2,['rating']] = 'E'

#Check
games_1[games_1['name'].isin(['Clockwork Empires','Supreme Ruler: Cold War', 'WRC: FIA World Rally Championship'])]

# Using games_2 to rename the RP to their designated locations


display(games_2[games_2['rating'] == 'RP'])

rp2_mask = (games_2['name'] == 'Clockwork Empires')
rp2_mask_1 = (games_2['name'] == 'Supreme Ruler: Cold War')
rp2_mask_2 = (games_2['name'] == 'WRC: FIA World Rally Championship')

#Input the data
games_2.loc[rp2_mask,['rating']] = 'T'
games_2.loc[rp2_mask_1,['rating']] = 'E10+'
games_2.loc[rp2_mask_2,['rating']] = 'E'

#Check
games_2[games_2['name'].isin(['Clockwork Empires','Supreme Ruler: Cold War', 'WRC: FIA World Rally Championship'])]

#Examine the data
games_1.info()

#This is still roughly 35% of the data which seems like a lot

games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10590 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB
<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10590 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB

#Look at the change
display(games_2['rating'].value_counts(ascending = True))

display(games_2['rating'].unique())

games_2['platform'].unique()

rating
EC       216
E10+    1470
M       1655
T       3091
E       4158
Name: count, dtype: int64

array(['E', nan, 'M', 'T', 'E10+', 'EC'], dtype=object)

array(['Wii', 'NES', 'GB', 'DS', 'X360', 'PS3', 'PS2', 'SNES', 'GBA',
       'PS4', '3DS', 'N64', 'PS', 'XB', 'PC', '2600', 'PSP', 'XOne',
       'WiiU', 'GC', 'GEN', 'DC', 'PSV', 'SAT', 'SCD', 'WS', 'NG', 'TG16',
       '3DO', 'GG', 'PCFX'], dtype=object)

#Analyze the 1470 E10+, 1655 M, 3091 T, &  4158 E games by genre
#Create a mask for each of these ratings


e10_games_2 = games_2[games_2['rating'] == 'E10+']
m_games_2 = games_2[games_2['rating'] == 'M']
t_games_2 = games_2[games_2['rating'] == 'T']
e_games_2 = games_2[games_2['rating'] == 'E']

#look at the info to determine NaN values
games_1.info()
games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10590 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB
<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16565 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10590 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16565 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB

# By era, exluding 80's; the ESRP did not come out until 1994


e10_90_2 = e10_games_2[e10_games_2['era'] == "90's"]
e10_00_2 = e10_games_2[e10_games_2['era'] == "2000's"]
e10_10_2 = e10_games_2[e10_games_2['era'] == "2010's"]



m_90_2 = m_games_2[m_games_2['era'] == "90's"]
m_00_2 = m_games_2[m_games_2['era'] == "2000's"]
m_10_2 = m_games_2[m_games_2['era'] == "2010's"]




t_90_2 = t_games_2[t_games_2['era'] == "90's"]
t_00_2 = t_games_2[t_games_2['era'] == "2000's"]
t_10_2 = t_games_2[t_games_2['era'] == "2010's"]




e_90_2 = e_games_2[e_games_2['era'] == "90's"]
e_00_2 = e_games_2[e_games_2['era'] == "2000's"]
e_10_2 = e_games_2[e_games_2['era'] == "2010's"]

# Look at the 90's, 2000's and 2010 data with game_2

# 90's

# Change the NaN values in rating that have both user_score and critic_score to E since that is their label
rating2_na_90 = (games_2[(games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "90's") & (games_2['rating'].isna())].sort_values(by = ['critic_score','user_score']))
display(rating2_na_90)

rating_90_mask = (games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "90's") & (games_2['rating'].isna())

games_2.loc[rating_90_mask,['rating']] = 'E'

display(games_2[games_2['name'] == 'Monster Rancher'])

rating2_notna_90 = (games_2[(games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "90's") & (games_2['rating'].notna())].sort_values(by = ['critic_score','user_score']))
display(rating2_notna_90)

#Although there are E10+ games rated from the 90's, the ESRB rating for E10+ did not come out until 2005

display(e10_90_2)
display(m_90_2)
display(t_90_2)
display(e_90_2)


display(e10_90_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(m_90_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(t_90_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(e_90_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))

display(rating2_notna_90['rating'].value_counts())

# T = 39
# E = 28
# M = 13

display(rating2_notna_90)

pivot2_rating_notna_90 = rating2_notna_90.pivot_table(index = ['rating','genre'], columns = 'year_of_release', values = 'name', aggfunc = 'count').fillna('')
display(pivot2_rating_notna_90)

pivot2_rating_sales_90 = rating2_notna_90.pivot_table(index = ['rating','total_sales_group'], columns = 'year_of_release', values= 'name',aggfunc = 'count').fillna('')
display(pivot2_rating_sales_90)

rating
T    39
E    28
M    13
Name: count, dtype: int64

# ESRB rating started in 1994
# Puzzle is only in E
display(games_2[(games_2['year_of_release'] > 1993) & (games_2['year_of_release'] < 2000) & (games_2['genre'] == 'Puzzle')])


puz2_90_mask = (games_2['year_of_release'] > 1993) & (games_2['year_of_release'] < 2000) & (games_2['genre'] == 'Puzzle')

games_2.loc[puz2_90_mask, ['rating']] = 'E'

display(games_2[games_2['name'] == 'Tetris Plus'])

# E in the 90's is only category with 10 million +
display(games_2[(games_2['year_of_release'] > 1993) & (games_2['year_of_release'] < 2000) & (games_2['total_sales_group'] == '10 million +')])

mill_10_mask = (games_2['year_of_release'] > 1993) & (games_2['year_of_release'] < 2000) & (games_2['total_sales_group'] == '10 million +')

games_2.loc[mill_10_mask,['rating']] = 'E'

display(games_2[games_2['name'] == 'Pokemon Red/Pokemon Blue'])

# Ranges of total_sales for E, M, & T
display(e_90_2['total_sales'].min(), e_90_2['total_sales'].max())
display(m_90_2['total_sales'].min(), m_90_2['total_sales'].max())
display(t_90_2['total_sales'].min(), t_90_2['total_sales'].max())

np.float64(0.01)

np.float64(10.95)

np.float64(0.01)

np.float64(6.03)

np.float64(0.02)

np.float64(9.719999999999999)

display(games_2[(games_2['rating'].isna()) & (games_2['era'] == "90's")])

# WHile exploring the data I saw a few titles that could be rated

display(games_2[games_2['name'].isin(['Twisted Metal 2', 'Twisted Metal 4', 'Vigilante 8','Vigilante 8: 2nd Offense'])])
mtv_mask = (games_2['name'].isin(['Twisted Metal 2', 'Twisted Metal 4', 'Vigilante 8','Vigilante 8: 2nd Offense']))
games_2.loc[mtv_mask,['rating']] = 'T'
display(games_2[games_2['name'].isin(['Twisted Metal 2', 'Twisted Metal 4', 'Vigilante 8','Vigilante 8: 2nd Offense'])])

display(games_2[games_2['name'].isin([['Twisted Metal 2', 'Twisted Metal 4', 'Vigilante 8','Vigilante 8: 2nd Offense']])])


# M - Rated

display(games_2[games_2['name'] == 'South Park Rally'])
mtv_mask = (games_2['name'] == 'South Park Rally')
games_2.loc[mtv_mask,['rating']] = 'M'
display(games_2[games_2['name'] == 'South Park Rally'])

# Let's explore the 2,000's and 2010's data


display(games_2['rating'].value_counts())

# 2000's


rating2_na_00 = (games_2[(games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "2000's") & (games_2['rating'].isna())].sort_values(by = ['critic_score','user_score']))
display(rating2_na_00)


rating2_notna_00 = (games_2[(games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "2000's") & (games_2['rating'].notna())].sort_values(by = ['critic_score','user_score']))
display(rating2_notna_00)


display(rating2_notna_00['rating'].value_counts())



# -----------------------------------------------------------------

# 2010's



rating2_na_10 = (games_2[(games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "2010's") & (games_2['rating'].isna())].sort_values(by = ['critic_score','user_score']))
display(rating2_na_10)


rating2_notna_10 = (games_2[(games_2['critic_score'].notna()) & (games_2['user_score'].notna()) & (games_2['era'] == "2010's") & (games_2['rating'].notna())].sort_values(by = ['critic_score','user_score']))
display(rating2_notna_10)

display(rating2_notna_10['rating'].value_counts())

rating
E       4219
T       3097
M       1657
E10+    1470
EC       216
Name: count, dtype: int64

rating
T       1695
E       1629
M        771
E10+     566
EC         1
Name: count, dtype: int64

rating
M       676
T       667
E       458
E10+    376
Name: count, dtype: int64

# 2000's

# See how many non-missing values are in each category

display(rating2_notna_00['rating'].value_counts())

# T       1695
# E       1629
# M        771
# E10+     566


# Remember the mask we made for the 2,000's per rating category
display(e10_00_2.head(5))
display(m_00_2.head(5))
display(t_00_2.head(5))
display(e_00_2.head(5))

rating
T       1695
E       1629
M        771
E10+     566
EC         1
Name: count, dtype: int64

display(games_2[(games_2['user_score'].notna() & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['era'] == "2000's"))])

# E - AMF Bowling 2004	
# M - The Void
# E10+ - Machinarium	

# Input a rating for the above games

display(games_2[games_2['name'] == 'AMF Bowling 2004'])
amf_mask = (games_2['name'] == 'AMF Bowling 2004')
games_2.loc[amf_mask,['rating']] = 'E'
display(games_2[games_2['name'] == 'AMF Bowling 2004'])


display(games_2[games_2['name'] == 'The Void'])
void_mask = (games_2['name'] == 'The Void')
games_2.loc[void_mask,['rating']] = 'M'
display(games_2[games_2['name'] == 'The Void'])


display(games_2[games_2['name'] == 'Machinarium'])
mach_mask = (games_2['name'] == 'Machinarium')
games_2.loc[mach_mask,['rating']] = 'E10+'
display(games_2[games_2['name'] == 'Machinarium'])

display(e10_00_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(m_00_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(t_00_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(e_00_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))



display(rating2_na_00)
display(rating2_notna_00)

pivot_rating2_notna_00 = rating2_notna_00.pivot_table(index = ['rating','genre'], columns = 'year_of_release', values = 'name', aggfunc = 'count').fillna('')
display(pivot_rating2_notna_00)

pivot_rating2_sales_00 = rating2_notna_00.pivot_table(index = ['rating','total_sales_group'], columns = 'year_of_release', values = 'name', aggfunc = 'count').fillna('')
display(pivot_rating2_sales_00)

# 2010's

display(rating2_notna_10['rating'].value_counts())


# M       676
# T       667
# E       458
# E10+    376

display(e10_10_2)
display(m_10_2)
display(t_10_2)
display(e_10_2)

display(e10_10_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(m_10_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(t_10_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))
display(e_10_2.groupby('genre')[['critic_score', 'user_score','total_sales']].mean().round(2).sort_values(by = 'total_sales',ascending = False))


display(rating2_na_10)
display(rating2_notna_10)

pivot_rating2_notna_10 = rating2_notna_10.pivot_table(index = ['rating','genre'], columns = 'year_of_release', values = 'name', aggfunc = 'count').fillna('')
display(pivot_rating2_notna_10)

pivot_rating2_sales_10 = rating2_notna_10.pivot_table(index = ['rating','total_sales_group'], columns = 'year_of_release', values = 'name', aggfunc = 'count').fillna('')
display(pivot_rating2_sales_10)

rating
M       676
T       667
E       458
E10+    376
Name: count, dtype: int64

# Put the names with a user_score and critic_score into the designated location

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['genre'] == 'Shooter') 
                 & (games_2['era'] == "2010's")])



shoo_10 = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['genre'] == 'Shooter') & (games_2['era'] == "2010's")


games_2.loc[shoo_10,['rating']] = 'M'

games_2[games_2['name'] == 'Zombie Army Trilogy']



display(games_2[games_2['name'] == 'DoDonPachi Resurrection'])
do_mask = (games_2['name'] == 'DoDonPachi Resurrection')
games_2.loc[do_mask,['rating']] = 'T'
display(games_2[games_2['name'] == 'DoDonPachi Resurrection'])

games_2[games_2['name'] == 'DoDonPachi Resurrection']

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['era'] == "2010's")])

rating_10 = games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].notna()) & (games_2['era'] == "2010's")]

display(rating_10.groupby(['rating','genre'])[['critic_score', 'user_score','total_sales']].min().round(2).sort_values(by = 'rating',ascending = False))
display(rating_10.groupby(['rating','genre'])[['critic_score', 'user_score','total_sales']].max().round(2).sort_values(by = 'rating',ascending = False))

# Input some of the known T-rated games

display(games_2[games_2['name'].isin(['Oil Rush', 'Act of Aggression','Toy Soldiers: War Chest'])])
                 
t_mask = games_2['name'].isin(['Oil Rush', 'Act of Aggression','Toy Soldiers: War Chest'])

games_2.loc[t_mask,['rating']] = 'T'

games_2[games_2['name'] == 'Oil Rush']

# Input the known M rating

games_2[games_2['name'] == 'The Binding of Isaac']

m_mask = games_2['name'] == 'The Binding of Isaac'

games_2.loc[m_mask,['rating']] = 'M'

display(games_2[games_2['name'] == 'The Binding of Isaac'])



# Input the known E ratings
games_2[games_2['name'].isin(['Botanicula','Cities: Skylines Snowfall'])]

e_mask = games_2['name'].isin(['Botanicula', 'Cities: Skylines Snowfall'])

games_2.loc[e_mask,['rating']] = 'E'

display(games_2[games_2['name'].isin(['Botanicula','Cities: Skylines Snowfall'])])


# Input the known E10+ ratings
games_2[games_2['name'].isin(['The Night of the Rabbit','Robinson: The Journey'])]


e10_mask = games_2['name'].isin(['The Night of the Rabbit','Robinson: The Journey'])

games_2.loc[e10_mask,['rating']] = 'E10+'

display(games_2[games_2['name'].isin(['The Night of the Rabbit','Robinson: The Journey'])])

# We will input 'No Rating' for the rest of the ratings in the 2010's that share a user_score and critic_score
# Here we are spcecifically looking at jp_sales


display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) 
     & (games_2['na_sales']  == 0) & (games_2['eu_sales']  == 0) & (games_2['other_sales']  == 0) & (games_2['era'] == "2010's")])


jp_sales_no_rating = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['na_sales']  == 0) & (games_2['eu_sales']  == 0) & (games_2['other_sales']  == 0) & (games_2['era'] == "2010's")

games_2.loc[jp_sales_no_rating,['rating']] = 'No Rating: JP Sales'

display(games_2[games_2['rating'] == 'No Rating: JP Sales'])

# We will input 'No Rating' for the rest of the ratings in the 2010's that share a user_score and critic_score
# Here we are spcecifically looking at eu_sales


display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())]) 

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) 
     & (games_2['na_sales']  == 0) & (games_2['jp_sales']  == 0) & (games_2['other_sales']  == 0) & (games_2['era'] == "2010's")])

eu_only = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['na_sales']  == 0) & (games_2['jp_sales']  == 0) & (games_2['other_sales']  == 0) & (games_2['era'] == "2010's")

games_2.loc[eu_only,['rating']] = 'No Rating: EU Sales'

display(games_2[games_2['rating'] == 'No Rating: EU Sales'])

# We will input 'No Rating' for the rest of the ratings in the 2010's that share a user_score and critic_score
# Here we are spcecifically looking at eu_sales AND jp_sales


display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())]) 

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) 
     & (games_2['na_sales']  == 0) & (games_2['other_sales']  == 0) & (games_2['era'] == "2010's")])

eu_jp_only = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['na_sales']  == 0) & (games_2['other_sales']  == 0) & (games_2['era'] == "2010's")

games_2.loc[eu_jp_only,['rating']] = 'No Rating: EU + JP Sales'

display(games_2[games_2['rating'] == 'No Rating: EU + JP Sales'])

saint_mask = (games_2['name'] == 'Saint Seiya: Brave Soldiers')

games_2.loc[saint_mask,['rating']] = 'T'

display(games_2[games_2['name'] == 'Saint Seiya: Brave Soldiers'])

# We will input 'No Rating' for the rest of the ratings in the 2010's that share a user_score and critic_score
# Here we are spcecifically looking at eu_sales AND other_sales


display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())]) 

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) 
     & (games_2['na_sales']  == 0) & (games_2['jp_sales']  == 0) & (games_2['era'] == "2010's")])

eu_other_only = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['na_sales']  == 0) & (games_2['jp_sales']  == 0) & (games_2['era'] == "2010's")

games_2.loc[eu_other_only,['rating']] = 'No Rating: EU + Other Sales'

display(games_2[games_2['rating'] == 'No Rating: EU + Other Sales'])

# Singstar: Ultimate Party is rated E

sing_mask = (games_2['name'] == 'Singstar: Ultimate Party')
games_2.loc[sing_mask,['rating']] = 'E'
display(games_2[games_2['name'] =='Singstar: Ultimate Party'])

# We will input 'No Rating' for the rest of the ratings in the 2010's that share a user_score and critic_score
# Here we are spcecifically looking at eu_sales AND other_sales


display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())]) 

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) 
     & (games_2['na_sales']  == 0) & (games_2['era'] == "2010's")])


t_rated = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna()) & (games_2['na_sales']  == 0)  & (games_2['era'] == "2010's")

games_2.loc[t_rated,['rating']] = 'T'

display(games_2[games_2['name'] == 'Saint Seiya: Sanctuary Battle'])

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())]) 

# Fix tour de France to rated E and year of release as 2011

tour_mask = (games_2['name'] == 'Tour de France 2011')

games_2.loc[tour_mask,['rating']] = 'E'
games_2.loc[tour_mask,['year_of_release']] = 2011

display(games_2[games_2['name'] == 'Tour de France 2011'])

display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())])

# No Rating: EU + Other Sales
# SuperCar Challenge

super_mask = (games_2['name'] == 'SuperCar Challenge')
games_2.loc[super_mask,['rating']] = 'No Rating: EU + Other Sales'

# No Rating: EU Sales
# Football Manager Live	
# 15 Days	

no_rating = (games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['rating'].isna())
games_2.loc[no_rating,['rating']] = 'No Rating: EU Sales'

display(games_2[games_2['name'].isin(['SuperCar Challenge','Football Manager Live','15 Days'])])

# Take a look at the missing year_of_release games
display(games_2[(games_2['user_score'].notna()) & (games_2['critic_score'].notna()) & (games_2['year_of_release'].isna())])

# Input the missing years; this line helped to check my work
games_2[games_2['name'].isin(['Clockwork Empires'])]

# 1999
    # ['Legacy of Kain: Soul Reaver']
# games_2[games_2['name'].isin(['Legacy of Kain: Soul Reaver'])]

mask_99 = games_2['name'].isin(['Legacy of Kain: Soul Reaver'])
games_2.loc[mask_99,['year_of_release']] = 1999
display(games_2[games_2['name'].isin(['Legacy of Kain: Soul Reaver'])])


# 2001
    # ['Harvest Moon: Save the Homeland','Twisted Metal: Small Brawl','Alone in the Dark: The New Nightmare']
# games_2[games_2['name'].isin(['Harvest Moon: Save the Homeland','Twisted Metal: Small Brawl','Alone in the Dark: The New Nightmare'])]
mask_01 = games_2['name'].isin(['Harvest Moon: Save the Homeland','Twisted Metal: Small Brawl','Alone in the Dark: The New Nightmare'])
games_2.loc[mask_01,['year_of_release']] = 2001
display(games_2[games_2['name'].isin(['Harvest Moon: Save the Homeland','Twisted Metal: Small Brawl','Alone in the Dark: The New Nightmare'])])


# 2002
    # ['Suikoden III','Haven: Call of the King','Tribes: Aerial Assault','eJay Clubworld']
# games_2[games_2['name'].isin(['Suikoden III','Haven: Call of the King','Tribes: Aerial Assault','eJay Clubworld'])
mask_02 = games_2['name'].isin(['Suikoden III','Haven: Call of the King','Tribes: Aerial Assault','eJay Clubworld'])
games_2.loc[mask_02,['year_of_release']] = 2002
display(games_2[games_2['name'].isin(['Suikoden III','Haven: Call of the King','Tribes: Aerial Assault','eJay Clubworld'])])


# 2003
    # ['Super Puzzle Fighter II','Drake of the 99 Dragons']
# games_2[games_2['name'].isin(['Super Puzzle Fighter II','Drake of the 99 Dragons'])]
mask_03 = games_2['name'].isin(['Super Puzzle Fighter II','Drake of the 99 Dragons'])
games_2.loc[mask_03,['year_of_release']] = 2003
display(games_2[games_2['name'].isin(['Super Puzzle Fighter II','Drake of the 99 Dragons'])])


# 2004
    # ['The Chronicles of Riddick: Escape from Butcher Bay','All-Star Baseball 2005','Yu Yu Hakusho: Dark Tournament','McFarlane's Evil Prophecy','Sabre Wulf']
# games_2[games_2['name'].isin(['The Chronicles of Riddick: Escape from Butcher Bay','All-Star Baseball 2005','Yu Yu Hakusho: Dark Tournament',"McFarlane's Evil Prophecy",'Sabre Wulf'])]
mask_04 = games_2['name'].isin(['The Chronicles of Riddick: Escape from Butcher Bay','All-Star Baseball 2005','Yu Yu Hakusho: Dark Tournament',"McFarlane's Evil Prophecy",'Sabre Wulf'])
games_2.loc[mask_04,['year_of_release']] = 2004
display(games_2[games_2['name'].isin(['The Chronicles of Riddick: Escape from Butcher Bay','All-Star Baseball 2005','Yu Yu Hakusho: Dark Tournament',"McFarlane's Evil Prophecy",'Sabre Wulf'])])


# 2005
    # ['Unreal Championship 2: The Liandri Conflict','Virtua Quest']
# games_2[games_2['name'].isin(['Unreal Championship 2: The Liandri Conflict','Virtua Quest'])]
mask_05 = games_2['name'].isin(['Unreal Championship 2: The Liandri Conflict','Virtua Quest'])
games_2.loc[mask_05,['year_of_release']] = 2005
display(games_2[games_2['name'].isin(['Unreal Championship 2: The Liandri Conflict','Virtua Quest'])])


# 2006
    # ['Alex Rider: Stormbreaker','Tom Clancy's Rainbow Six: Critical Hour','Drill Dozer']
# games_2[games_2['name'].isin(['Alex Rider: Stormbreaker',"Tom Clancy's Rainbow Six: Critical Hour",'Drill Dozer'])]
mask_06 = games_2['name'].isin(['Alex Rider: Stormbreaker',"Tom Clancy's Rainbow Six: Critical Hour",'Drill Dozer'])
games_2.loc[mask_06,['year_of_release']] = 2006
display(games_2[games_2['name'].isin(['Alex Rider: Stormbreaker',"Tom Clancy's Rainbow Six: Critical Hour",'Drill Dozer'])])


# 2008
    # ['Rock Band','Advance Wars: Days of Ruin','Silent Hill: Homecoming','Robert Ludlum's The Bourne Conspiracy']
    # Only the Wii version of Rock Band was 08
# games_2[games_2['name'].isin(['Rock Band','Advance Wars: Days of Ruin','Silent Hill: Homecoming',"Robert Ludlum's The Bourne Conspiracy"])]
mask_08 = games_2['name'].isin(['Rock Band','Advance Wars: Days of Ruin','Silent Hill: Homecoming',"Robert Ludlum's The Bourne Conspiracy"])
games_2.loc[mask_08,['year_of_release']] = 2008
display(games_2[games_2['name'].isin(['Rock Band','Advance Wars: Days of Ruin','Silent Hill: Homecoming',"Robert Ludlum's The Bourne Conspiracy"])])


# 2010
    # ['NHL Slapshot','Backbreaker','Trauma Team']
# games_2[games_2['name'].isin(['NHL Slapshot','Backbreaker','Trauma Team'])]
mask_10 = games_2['name'].isin(['NHL Slapshot','Backbreaker','Trauma Team'])
games_2.loc[mask_10,['year_of_release']] = 2010
display(games_2[games_2['name'].isin(['NHL Slapshot','Backbreaker','Trauma Team'])])


# 2011
     # ['Yakuza 4','Test Drive Unlimited 2','Otomedius Excellent','Jurassic Park: The Game','Dream Trigger 3D']
# games_2[games_2['name'].isin(['Yakuza 4','Test Drive Unlimited 2','Otomedius Excellent','Jurassic Park: The Game','Dream Trigger 3D'])]
mask_11 = games_2['name'].isin(['Yakuza 4','Test Drive Unlimited 2','Otomedius Excellent','Jurassic Park: The Game','Dream Trigger 3D'])
games_2.loc[mask_11,['year_of_release']] = 2011
display(games_2[games_2['name'].isin(['Yakuza 4','Test Drive Unlimited 2','Otomedius Excellent','Jurassic Park: The Game','Dream Trigger 3D'])])


# 2012
    # ['TERA','Disgaea 3: Absence of Detention','Port Royale 3']
# games_2[games_2['name'].isin(['TERA','Disgaea 3: Absence of Detention','Port Royale 3'])]
mask_12 = games_2['name'].isin(['TERA','Disgaea 3: Absence of Detention','Port Royale 3'])
games_2.loc[mask_12,['year_of_release']] = 2012
display(games_2[games_2['name'].isin(['TERA','Disgaea 3: Absence of Detention','Port Royale 3'])])


# 2015
    # ['Homeworld Remastered Collection	']
# games_2[games_2['name'].isin(['Homeworld Remastered Collection'])]
mask_15 = games_2['name'].isin(['Homeworld Remastered Collection'])
games_2.loc[mask_15,['year_of_release']] = 2015
display(games_2[games_2['name'].isin(['Homeworld Remastered Collection'])])


# 2016
    # ['Clockwork Empires']
# games_2[games_2['name'].isin(['Clockwork Empires'])]
mask_16 = games_2['name'].isin(['Clockwork Empires'])
games_2.loc[mask_16,['year_of_release']] = 2016
display(games_2[games_2['name'].isin(['Clockwork Empires'])])

# Check missing ratings that have a user_score
display(games_2[(games_2['user_score'].notna()) & (games_2['rating'].isna())])


# E10+
games_2[games_2['name'] == "Cabela's Big Game Hunter: Hunting Party"]
c_mask = games_2['name'] == "Cabela's Big Game Hunter: Hunting Party"
games_2.loc[c_mask,['rating']] = 'E10+'
display(games_2[games_2['name'] == "Cabela's Big Game Hunter: Hunting Party"])

# E
games_2[games_2['name'] == 'Batman Beyond: Return of the Joker']
b_mask = games_2['name'] == 'Batman Beyond: Return of the Joker'
games_2.loc[b_mask,['rating']] = 'E'
display(games_2[games_2['name'] == 'Batman Beyond: Return of the Joker'])

# T
games_2[games_2['name'] == 'Paragon']
p_mask = games_2['name'] == 'Paragon'
games_2.loc[p_mask,['rating']] = 'T'
display(games_2[games_2['name'] == 'Paragon'])

# M
games_2[games_2['name'] == 'Fallout Anthology']
f_mask = games_2['name'] == 'Fallout Anthology'
games_2.loc[f_mask,['rating']] = 'M'
display(games_2[games_2['name'] == 'Fallout Anthology'])

# Check missing ratings that have a user_score, again
display(games_2[(games_2['user_score'].notna()) & (games_2['rating'].isna())])


# EU + Other Sales
games_2[games_2['name'] == 'Euro Truck Simulator']
e_truck = games_2['name'] == 'Euro Truck Simulator'
games_2.loc[e_truck,['rating']] = 'No Rating: EU + Other Sales'
display(games_2[games_2['name'] == 'Euro Truck Simulator'])

#  EU Sales
games_2[games_2['name'] == '18 Wheels of Steel: Extreme Trucker']
truck_18 = games_2['name'] == '18 Wheels of Steel: Extreme Trucker'
games_2.loc[truck_18,['rating']] = 'No Rating: EU Sales'
display(games_2[games_2['name'] == '18 Wheels of Steel: Extreme Trucker'])

# Check missing ratings that have a critic_score
display(games_2[(games_2['critic_score'].notna()) & (games_2['rating'].isna())])

# E
# 'MTV Sports: Pure Ride'	
games_2[games_2['name'] == 'MTV Sports: Pure Ride']
mtv = games_2['name'] == 'MTV Sports: Pure Ride'
games_2.loc[mtv,['rating']] = 'E'
display(games_2[games_2['name'] == 'MTV Sports: Pure Ride'])

# EU + JP Sales
# ['Disaster: Day of Crisis','Another Code R: A Journey into Lost Memories']
games_2[games_2['name'].isin(['Disaster: Day of Crisis','Another Code R: A Journey into Lost Memories'])]
da = games_2['name'].isin(['Disaster: Day of Crisis','Another Code R: A Journey into Lost Memories'])
games_2.loc[da,['rating']] = 'No Rating: EU + JP Sales'
display(games_2[games_2['name'].isin(['Disaster: Day of Crisis','Another Code R: A Journey into Lost Memories'])])

# EU Sales
# ['Doodle Hex','Gobliiins 4']
games_2[games_2['name'].isin(['Doodle Hex','Gobliiins 4'])]
dg = games_2['name'].isin(['Doodle Hex','Gobliiins 4'])
games_2.loc[dg,['rating']] = 'No Rating: EU Sales'
display(games_2[games_2['name'].isin(['Doodle Hex','Gobliiins 4'])])

# Look at missing year with a user_score and a rating
games_2[(games_2['year_of_release'].isna()) & (games_2['user_score'].notna()) & (games_2['rating'].notna())]

games_2[games_2['name'] == 'The Hidden']
h = games_2['name'] == 'The Hidden'
games_2.loc[h,['year_of_release']] = 2011
display(games_2[games_2['name'] == 'The Hidden'])

# Look at the rating and year of release
games_2[(games_2['year_of_release'].isna()) & (games_2['other_sales'] == 0) & (games_2['jp_sales'] == 0) & (games_2['na_sales'] == 0)]

# I noticed 'Football Manager 2007' did not come out on X360 in europe, since the sales are only in europe, I will change 'Worldwide Soccer...' to Football Manager 2007
# and change from X360 to PSP
display(games_2[games_2['name'] == 'Football Manager 2007'])
psp = games_2['name'] == 'Football Manager 2007'
games_2.loc[psp,['platform']] = 'PSP'

games_2[games_2['name'] == 'Worldwide Soccer Manager 2007']
fm = games_2['name'] == 'Worldwide Soccer Manager 2007'
games_2.loc[fm,['name']] = 'Football Manager 2007'



display(games_2[games_2['name'] == 'Football Manager 2007'])

# Now input the proper rating and year for Football Manager 2007
fy = games_2['name'] == 'Football Manager 2007'
games_2.loc[fy,['year_of_release']] = 2006
games_2.loc[fy,['rating']] = 'E'

display(games_2[games_2['name'] == 'Football Manager 2007'])

# Found a few games released in 2009
games_2[(games_2['platform'] == 'Wii') & (games_2['eu_sales'] == 0) & (games_2['year_of_release'].isna())] 

m_09 = games_2['name'].isin(['Vegas Party', 'The Daring Game for Girls','Build-A-Bear Workshop: Friendship Valley','Reader Rabbit 2nd Grade',
                             'Wii de Asobu: Metroid Prime',"Yu-Gi-Oh! 5D's Wheelie Breakers (JP sales)",'Tornado','Steal Princess','Charm Girls Club: My Fashion Mall',
                            'Dream Dancer','Mega Man Battle Network: Operation Shooting Star','Legacy of Ys: Books I & II',
                            'DanceDanceRevolution II','Zero: Tsukihami no Kamen','Charm Girls Club: My Fashion Show','My Healthy Cooking Coach',
                             'Prinny: Can I Really Be The Hero? (US sales)'])

games_2.loc[m_09,['year_of_release']] = 2009

display(games_2[games_2['name'].isin(['Vegas Party', 'The Daring Game for Girls','Build-A-Bear Workshop: Friendship Valley','Reader Rabbit 2nd Grade',
                                      'Wii de Asobu: Metroid Prime',"Yu-Gi-Oh! 5D's Wheelie Breakers (JP sales)",'Tornado','Steal Princess','Charm Girls Club: My Fashion Mall',
                                     'Dream Dancer','Mega Man Battle Network: Operation Shooting Star','Legacy of Ys: Books I & II',
                                      'DanceDanceRevolution II','Zero: Tsukihami no Kamen','Charm Girls Club: My Fashion Show','My Healthy Cooking Coach',
                                      'Prinny: Can I Really Be The Hero? (US sales)'])])

# NaN games belonging to the year 2005

# ['Disney's Cinderella: Magical Dreams','Combat Elite: WWII Paratroopers','Samurai Spirits: Tenkaichi Kenkakuden','The King of Fighters: Maximum Impact - Maniax','Payout Poker & Casino','Bikkuriman Daijiten']

games_2[games_2['name'].isin(["Disney's Cinderella: Magical Dreams",'Combat Elite: WWII Paratroopers','Samurai Spirits: Tenkaichi Kenkakuden',
                              'The King of Fighters: Maximum Impact - Maniax','Payout Poker & Casino','Bikkuriman Daijiten','wwe Smackdown vs. Raw 2006',
                              'WarioWare: Twisted!','Demon Chaos','Egg Monster Hero'])]

m_05 = games_2['name'].isin(["Disney's Cinderella: Magical Dreams",'Combat Elite: WWII Paratroopers','Samurai Spirits: Tenkaichi Kenkakuden',
                              'The King of Fighters: Maximum Impact - Maniax','Payout Poker & Casino','Bikkuriman Daijiten','wwe Smackdown vs. Raw 2006',
                             'WarioWare: Twisted!','Demon Chaos','Egg Monster Hero'])

games_2.loc[m_05,['year_of_release']] = 2005


display(games_2[games_2['name'].isin(["Disney's Cinderella: Magical Dreams",'Combat Elite: WWII Paratroopers','Samurai Spirits: Tenkaichi Kenkakuden',
                              'The King of Fighters: Maximum Impact - Maniax','Payout Poker & Casino','Bikkuriman Daijiten','wwe Smackdown vs. Raw 2006',
                                      'WarioWare: Twisted!','Demon Chaos','Egg Monster Hero'])])

# NaN games belonging to the year 2006

# ['Monster Hunter 2','Atsumare! Power Pro Kun no DS Koushien','Chou Soujuu Mecha MG','Sega Rally 2006','Shonen Jump's Yu-Gi-Oh! GX Card Almanac']


games_2[games_2['name'].isin(['Monster Hunter 2','Atsumare! Power Pro Kun no DS Koushien','Chou Soujuu Mecha MG','Sega Rally 2006',
                              "Shonen Jump's Yu-Gi-Oh! GX Card Almanac",'Saru! Get You! Million Monkeys'])]

m_06 = games_2['name'].isin(['Monster Hunter 2','Atsumare! Power Pro Kun no DS Koushien','Chou Soujuu Mecha MG','Sega Rally 2006',
                              "Shonen Jump's Yu-Gi-Oh! GX Card Almanac",'Saru! Get You! Million Monkeys'])

games_2.loc[m_06,['year_of_release']] = 2006

display(games_2[games_2['name'].isin(['Monster Hunter 2','Atsumare! Power Pro Kun no DS Koushien','Chou Soujuu Mecha MG','Sega Rally 2006',
                              "Shonen Jump's Yu-Gi-Oh! GX Card Almanac",'Saru! Get You! Million Monkeys'])])

# NaN games belonging to the year 2010

# ['Flip’s Twisted World','Ferrari: The Race Experience','Saint','Swords']
games_2[games_2['name'].isin(["Flip's Twisted World",'Ferrari: The Race Experience','Saint','Swords'])]

m_10 = games_2['name'].isin(["Flip's Twisted World",'Ferrari: The Race Experience','Saint','Swords'])
games_2.loc[m_10,['year_of_release']] = 2010


games_2[games_2['name'].isin(["Flip's Twisted World",'Ferrari: The Race Experience','Saint','Swords'])]

# 2011 missing 

# ['Yoostar on MTV','Half-Minute Hero 2']

games_2[games_2['name'].isin(['Yoostar on MTV','Half-Minute Hero 2'])]

m_11 = games_2['name'].isin(['Yoostar on MTV','Half-Minute Hero 2'])

games_2.loc[m_11,['year_of_release']] = 2011

games_2[games_2['name'].isin(['Yoostar on MTV','Half-Minute Hero 2'])]

# 2012 missing

# ['Combat Wings: The Great Battles of WWII','Umineko no Naku Koro ni San: Shinjitsu to Gensō','Hakuouki: Shinsengumi Kitan']

games_2[games_2['name'].isin( ['Combat Wings: The Great Battles of WWII','Umineko no Naku Koro ni San: Shinjitsu to Gensou no Yasoukyoku','Hakuouki: Shinsengumi Kitan',
                              'Beyond the Labyrinth'])]

m_12 = games_2['name'].isin( ['Combat Wings: The Great Battles of WWII','Umineko no Naku Koro ni San: Shinjitsu to Gensou no Yasoukyoku','Hakuouki: Shinsengumi Kitan',
                             'Beyond the Labyrinth'])
games_2.loc[m_12,['year_of_release']] = 2012

games_2[games_2['name'].isin( ['Combat Wings: The Great Battles of WWII','Umineko no Naku Koro ni San: Shinjitsu to Gensou no Yasoukyoku','Hakuouki: Shinsengumi Kitan',
                              'Beyond the Labyrinth'])]

# 2000

m_00 = games_2['name'] == 'The Dukes of Hazzard II: Daisy Dukes It Out'

games_2.loc[m_00,['year_of_release']] = 2000


# 2001

m_01 = games_2['name'] == "Frogger's Adventures: Temple of the Frog"

games_2.loc[m_01,['year_of_release']] = 2001


# 2002
# ['NFL GameDay 2003', 'Jet X20']

m_02 = games_2['name'].isin(['NFL GameDay 2003', 'Jet X20'])

games_2.loc[m_02,['year_of_release']] = 2002


# 2003
# ['Super Duper Sumos','Tube Slider']

m_03 = games_2['name'].isin(['Super Duper Sumos','Tube Slider'])

games_2.loc[m_03,['year_of_release']] = 2003

games_2[games_2['name'].isin(['Super Duper Sumos','Tube Slider'])]

# Look at the missing atari data

# I am going to turn all of this data to 1980 since most of the games are around that time
# First Ghostbusters II was an unofficial Atari game released in 1992, after subtantial decline in support for the Atari console

display(games_2[(games_2['year_of_release'].isna()) & (games_2['platform'] == '2600')])

m_92 = games_2['name'] == 'Ghostbusters II'
games_2.loc[m_92,['year_of_release']] = 1992
games_2[games_2['name'] == 'Ghostbusters II']

# The remaining Atari data came out between 1977 - 1982; I am going to put them all as 1980, this will prevent my era group from becoming distorted since there is 
# no era group for the 70's

atari = games_2['year_of_release'].isna() & (games_2['platform'] == '2600')
games_2.loc[atari,['year_of_release']] = 1980

display(games_2[(games_2['year_of_release'] == 1980) & (games_2['platform'] == '2600')])

# Fix the 'era group'
games_2['era'] = games_2['year_of_release'].apply(era_group)

# Look at the data
games_2.info()
display(games_2.isnull().sum())

games_2.hist()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 16 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10720 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
dtypes: float64(8), object(8)
memory usage: 2.2+ MB

name                     0
platform                 0
year_of_release         28
genre                    0
na_sales                 0
eu_sales                 0
jp_sales                 0
other_sales              0
critic_score          8576
user_score            9123
rating                5991
total_sales              0
critic_score_group    8341
user_score_group      8888
total_sales_group        0
era                     28
dtype: int64

array([[<Axes: title={'center': 'year_of_release'}>,
        <Axes: title={'center': 'na_sales'}>,
        <Axes: title={'center': 'eu_sales'}>],
       [<Axes: title={'center': 'jp_sales'}>,
        <Axes: title={'center': 'other_sales'}>,
        <Axes: title={'center': 'critic_score'}>],
       [<Axes: title={'center': 'user_score'}>,
        <Axes: title={'center': 'total_sales'}>, <Axes: >]], dtype=object)

# Were still missing significant rating, critic_score, and user_score data

# Look at the rating data again

# Create a mask for the known ratings:



e10_mask = games_2[games_2['rating'] == 'E10+']
t_mask = games_2[games_2['rating'] == 'T']
m_mask = games_2[games_2['rating'] == 'M']
e_mask = games_2[games_2['rating'] == 'E']

display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['jp_sales'] == 0) & (games_2['eu_sales'] == 0)])

gs = games_2['name'].isin(['SCORE International Baja 1000: The Official Game','G1 Jockey 4 2008'])

games_2.loc[gs,['rating']] = 'E'

games_2[games_2['name'].isin(['SCORE International Baja 1000: The Official Game','G1 Jockey 4 2008'])]

def esrb(era):
    if era < 1994:
        return 'pre-ERSB'
    elif era < 2005:
        return 'pre-(EC,E10+)'
    elif era >= 2005:
        return 'All Available'
    else:
        return np.nan

games_2['esrb_era'] = games_2['year_of_release'].apply(esrb)

display(games_2)

# E
games_2[games_2['name'].isin(['Bomberman (jp sales)','NiGHTS into dreams...','RalliSport Challenge(JP sales)','Legoland','Football Manager 2005		'])]
b = games_2['name'].isin(['Bomberman (jp sales)','NiGHTS into dreams...','RalliSport Challenge(JP sales)','	Legoland'])
display(games_2[games_2['name'].isin(['Bomberman (jp sales)','NiGHTS into dreams...','RalliSport Challenge(JP sales)','	Legoland','Football Manager 2005'])])

games_2.loc[b,['rating']] = 'E'
    
# T
games_2[games_2['name'].isin(['Samurai Warriors: Sanada Maru','Haitaka no Psychedelica',"Tom Clancy's  Ghost Recon Advanced Warfighter (weekly JP sales)",
                              'Period Cube: Torikago no Amadeus','Samurai Shodown Anthology (JP sales)','The Legend of Heroes: Trails in the Sky Third Chapter'])]
c = games_2['name'].isin(['Samurai Warriors: Sanada Maru','Haitaka no Psychedelica',"Tom Clancy's  Ghost Recon Advanced Warfighter (weekly JP sales)",
                              'Period Cube: Torikago no Amadeus','Samurai Shodown Anthology (JP sales)','The Legend of Heroes: Trails in the Sky Third Chapter'])
games_2.loc[c,['rating']] = 'T'


display(games_2[games_2['name'].isin(['Samurai Warriors: Sanada Maru','Haitaka no Psychedelica',"Tom Clancy's  Ghost Recon Advanced Warfighter (weekly JP sales)",
                              'Period Cube: Torikago no Amadeus','Samurai Shodown Anthology (JP sales)','The Legend of Heroes: Trails in the Sky Third Chapter'])])

# M
games_2[games_2['name'].isin(['Rengoku II: The Stairway to H.E.A.V.E.N. (jp sales)'])]

d = games_2['name'].isin(['Rengoku II: The Stairway to H.E.A.V.E.N. (jp sales)'])

games_2.loc[d,['rating']] = 'M'

display(games_2[games_2['name'].isin(['Rengoku II: The Stairway to H.E.A.V.E.N. (jp sales)'])])

# E
games_2[games_2['name'].isin(['Bomberman (jp sales)','NiGHTS into dreams...','RalliSport Challenge(JP sales)','Legoland','Football Manager 2005',
                              'Championship Manager Season 01/02','Zoo Tycoon','The Settlers IV',"Mickey's Speedway USA (weekly JP sales)",
                              'Project FIFA World Cup','Pro Yakyuu Greatest Nine 98','FIFA 2001: Major League Soccer','EA Sports Grand Slam Tennis'])]
b = games_2['name'].isin(['Bomberman (jp sales)','NiGHTS into dreams...','RalliSport Challenge(JP sales)','Legoland','Football Manager 2005',
                          'Championship Manager Season 01/02','Zoo Tycoon','The Settlers IV',"Mickey's Speedway USA (weekly JP sales)",
                          'Project FIFA World Cup','Pro Yakyuu Greatest Nine 98','FIFA 2001: Major League Soccer','EA Sports Grand Slam Tennis'])
display(games_2[games_2['name'].isin(['Bomberman (jp sales)','NiGHTS into dreams...','RalliSport Challenge(JP sales)','Legoland','Football Manager 2005',
                                      'Championship Manager Season 01/02','Zoo Tycoon','The Settlers IV',"Mickey's Speedway USA (weekly JP sales)",
                                      'Project FIFA World Cup','Pro Yakyuu Greatest Nine 98','FIFA 2001: Major League Soccer','EA Sports Grand Slam Tennis'])])

games_2.loc[b,['rating']] = 'E'




# T
games_2[games_2['name'].isin(['Samurai Warriors: Sanada Maru','Haitaka no Psychedelica',"Tom Clancy's  Ghost Recon Advanced Warfighter (weekly JP sales)",
                              'Period Cube: Torikago no Amadeus','Samurai Shodown Anthology (JP sales)','The Legend of Heroes: Trails in the Sky Third Chapter',
                              'Command & Conquer Renegade','Black & White','The King of Fighters: Dream Match 1999','Darius Gaiden',
                              'Marvel vs. Capcom: Clash of Super Heroes','Samurai Shodown III'])]
c = games_2['name'].isin(['Samurai Warriors: Sanada Maru','Haitaka no Psychedelica',"Tom Clancy's  Ghost Recon Advanced Warfighter (weekly JP sales)",
                              'Period Cube: Torikago no Amadeus','Samurai Shodown Anthology (JP sales)','The Legend of Heroes: Trails in the Sky Third Chapter',
                          'Command & Conquer Renegade','Black & White','The King of Fighters: Dream Match 1999','Darius Gaiden',
                          'Marvel vs. Capcom: Clash of Super Heroes','Samurai Shodown III'])
games_2.loc[c,['rating']] = 'T'


display(games_2[games_2['name'].isin(['Samurai Warriors: Sanada Maru','Haitaka no Psychedelica',"Tom Clancy's  Ghost Recon Advanced Warfighter (weekly JP sales)",
                              'Period Cube: Torikago no Amadeus','Samurai Shodown Anthology (JP sales)','The Legend of Heroes: Trails in the Sky Third Chapter',
                                      'Command & Conquer Renegade','Black & White','The King of Fighters: Dream Match 1999','Darius Gaiden',
                                      'Marvel vs. Capcom: Clash of Super Heroes','Samurai Shodown III'])])


# M
games_2[games_2['name'].isin(['Rengoku II: The Stairway to H.E.A.V.E.N. (jp sales)','Blue Stinger'])]

d = games_2['name'].isin(['Rengoku II: The Stairway to H.E.A.V.E.N. (jp sales)','Blue Stinger'])

games_2.loc[d,['rating']] = 'M'

display(games_2[games_2['name'].isin(['Rengoku II: The Stairway to H.E.A.V.E.N. (jp sales)','Blue Stinger'])])

# FIFA games tend to be rated E, let's change all NaN FIFA games to 'E'
fifa_rows = games_2['name'].str.contains("FIFA", case=False, na=False)

display(fifa_rows)


games_2.loc[fifa_rows,['rating']] = 'E'

games_2[games_2['name'].str.contains("FIFA", case=False, na=False)]

0        False
1        False
2        False
3        False
4        False
         ...  
16710    False
16711    False
16712    False
16713    False
16714    False
Name: name, Length: 16711, dtype: bool

# Seems to be some Famicom rows that are not rated due to only being in Japan
famicom_rows = games_2[games_2['name'].str.contains('Famicom',case = False,na=False)]

display(famicom_rows)

fr = games_2['name'].str.contains('Famicom',case = False,na=False)

games_2.loc[fr,['rating']] = 'No Rating: JP Sales'

famicom_rows

display(games_2[games_2['name']=='Famicom Jump: Eiyuu Retsuden'])

# Check out games with Mario in the title

mario_rows = games_2[games_2['name'].str.contains('Mario ',case = False,na=False)]
display(mario_rows)

mario_rows['rating'].value_counts()

mario_rows[mario_rows['rating'].isna()]


# Mario Strikers Charged only E10+ and it is on a Wii

# Since most Mario games are E, we will rename the rating to 'E'

mario = games_2['name'].str.contains('Mario ',case = False,na=True)

games_2.loc[mario,['rating']] = 'E'

display(games_2[games_2['name'].str.contains('Mario ',case = False,na=True)])


strikers = games_2['name'] == 'Mario Strikers Charged'

games_2.loc[strikers, ['rating']]  = 'E10+'

# Minecraft games are rated E10+
mc_rows = games_2['name'].str.contains('minecraft',case = False,na=False)

games_2.loc[mc_rows,['rating']] = 'E10+'

display(games_2[games_2['name'].str.contains('minecraft',case = False,na=False)])

# Let's look at Pokemon games
games_2[games_2['name'].str.contains('pokemon', case=False, na=False)]

# The pokemon rumble games are E10+ and the rest should be E

pokemon = games_2['name'].str.contains('pokemon', case=False, na=False)
rumble = games_2['name'].str.contains('pokemon rumble', case=False, na=False)

games_2.loc[pokemon,['rating']] = 'E'
games_2.loc[rumble, ['rating']] = 'E10+'

games_2[games_2['name'].str.contains('pokemon', case=False, na=False)]

games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              10880 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

# Check out Call of Duty games

games_2[(games_2['name'].str.contains('call of duty',case=False,na=False)) & (games_2['year_of_release'] > 2006) & (~(games_2['name'].isin(['Call of Duty: Roads to Victory'])))]

# ALl COD games after 2006 are rated M except Call of Duty: Roads to Victory		
cod = (games_2['name'].str.contains('call of duty',case=False,na=False)) & (games_2['year_of_release'] > 2006) & (~(games_2['name'].isin(['Call of Duty: Roads to Victory'])))

games_2.loc[cod,['rating']] = 'M'

# Let's check out star wars games since they are very popular
star = games_2[(games_2['name'].str.contains('star wars', case = False, na= False)) & (games_2['rating'].notna())]
display(star)


display(star['rating'].value_counts())

# All star wars empire games are rated T
empire = (games_2['name'].str.contains('star wars: empire at war', case = False, na= False))
games_2.loc[empire,['rating']] = 'T'

# All shooter, simulation, adventure, and misc star wars games are rated T
shooter_star = (games_2['name'].str.contains('star wars', case = False, na= False)) & (games_2['genre'].isin(['Shooter','Simulation','Adventure','Misc']))
games_2.loc[shooter_star,['rating']] = 'T'


# Less than 2000 is T; greater than the remaining NaN after 2000 are E
t_00 = (games_2['name'].str.contains('star wars', case = False, na= False)) & (games_2['year_of_release'] < 2000) & (games_2['rating'].isna())
games_2.loc[t_00,['rating']] = 'T'

e_00 = (games_2['name'].str.contains('star wars', case = False, na= False)) & (games_2['year_of_release'] > 2000) & (games_2['rating'].isna())
games_2.loc[e_00,['rating']] = 'E'

rating
T       55
E10+    28
E       17
Name: count, dtype: int64

# Check the difference
    # Before:
        # T: 55
        # E10: 28
        # E: 17
    # After:
        # T: 74
        # E10: 27
        # E: 22

# The majority are rated T

star_1 = games_2[(games_2['name'].str.contains('star wars', case = False, na= False)) & (games_2['rating'].isna())]
display(star_1)

star_2 = games_2[(games_2['name'].str.contains('star wars', case = False, na= False)) & (games_2['rating'].notna())]
display(star_2)

star_2['rating'].value_counts()

rating
T       74
E10+    27
E       22
Name: count, dtype: int64

# From previous data we know that most of the Puzzle data is rated E, let's look
display(games_2[(games_2['name'].str.contains('Professor Layton and', case = False, na= False))])


# We know that most of the Professor Layton games are E10+
lay = (games_2['name'].str.contains('Professor Layton and', case = False, na= False))
games_2.loc[lay,['rating']] = 'E10+'
display(games_2[(games_2['name'].str.contains('Professor Layton and', case = False, na= False))])

# Look at the T rated games and ensure they are correct; there are 5 in the incorrect spot

puz_5 = (games_2['genre'] == 'Puzzle') & (games_2['platform'] != 'PSP') & (games_2['year_of_release'] > 2006) & (games_2['year_of_release'] < 2011) & (games_2['rating'] == 'T')

games_2.loc[puz_5,['rating']] = "E"

# Some of the E10+ category is mislabled
games_2[games_2['name'].isin(['Jumble Madness',"Margot's Word Brain", 'Yard Sale Hidden Treasures: Sunnyville', 'Jewel Master: Cradle of Athena','TouchMaster',
                             'WarioWare: Smooth Moves','GunPey','Challenge Me: Word Puzzles'])]

change = games_2['name'].isin(['Jumble Madness',"Margot's Word Brain", 'Yard Sale Hidden Treasures: Sunnyville', 'Jewel Master: Cradle of Athena','TouchMaster',
                              'WarioWare: Smooth Moves','GunPey','Challenge Me: Word Puzzles'])
games_2.loc[change,['rating']] = 'E'
# To test, use the line below
# display(games_2[games_2['name'].isin(['Jumble Madness',"Margot's Word Brain", 'Yard Sale Hidden Treasures: Sunnyville', 'Jewel Master: Cradle of Athena','TouchMaster',
                                     #'WarioWare: Smooth Moves','GunPey','Challenge Me: Word Puzzles'])])

# Further explore the E10+ section of Puzzle to ensure the correct placement
games_2[(games_2['genre'] == 'Puzzle') & (games_2['rating'] == 'E10+')]

puzzle = games_2[(games_2['genre'] == 'Puzzle') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))]

display(puzzle['rating'].value_counts())

# There are a substantial amount of Puzzle games that are rated E
    # E: 369    (90.2%)
    # E10: 35   (8.6&)
    # T: 5      (1.2 %)

# We will look at the data, but most of the puzzle data is probably E
    

games_2[(games_2['genre'] == 'Puzzle') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'].isna())]

# Let's fix some of these
games_2[(games_2['name'].str.contains('Kotoba', case = False, na= False))]
games_2[(games_2['name'].str.contains('Puyo', case = False, na= False))]
games_2[(games_2['name'].str.contains('sloane', case = False, na= False))]

# These are E rated
# ['Puyo Puyo Tetris', 'Puyo Pop','Puyo Pop Fever(us sales)','Puyo Pop Fever']


#No Rating: JP Sales
#Kotoba no Puzzle: Mojipittan DS	
#Puyo Pop Fever (JP sales)
#(Not Puyo Tetris)
#Sloane to MacHale no Nazo no Monogatari 2	

jp = (games_2['name'].str.contains('Kotoba', case = False, na= False)) | (games_2['name'].str.contains('Puyo', case = False, na= False)) | (games_2['name'].str.contains('sloane', case = False, na= False)) 
games_2.loc[jp,['rating']] = 'No Rating: JP Sales'

# Some Puyo's are E rated
puyo = games_2['name'].isin(['Puyo Puyo Tetris', 'Puyo Pop','Puyo Pop Fever(us sales)','Puyo Pop Fever'])

games_2.loc[puyo,['rating']] = 'E'

games_2[(games_2['genre'] == 'Puzzle') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'] == 'No Rating: JP Sales')]

# Look at the NaN values in puzzle again
games_2[(games_2['genre'] == 'Puzzle') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'].isna())].head(60)


#There are more with No Rating

k = (games_2['name'].str.contains('Kumamon', case = False, na= False)) | (games_2['name'].str.contains('Kururin', case = False, na= False)) | (games_2['name'].str.contains('Mawashite', case = False, na= False)) 
games_2.loc[k,['rating']] = 'No Rating: JP Sales'
    

#T
#The Rub Rabbits!
rab = games_2['name'] == 'The Rub Rabbits!'
games_2.loc[rab,['rating']] = 'T'


# The rest of the puzzle games are most likely rated E, but we've made the data more accurate
pg = (games_2['genre'] == 'Puzzle') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'].isna())
games_2.loc[pg,['rating']] = 'E'

games_2[(games_2['genre'] == 'Puzzle') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'].isna())].head(60)


# THe rating are still mostly E at 475, that's about 92% or 87.6% if you include the not rated games

rating
E                      369
E10+                    35
T                        5
No Rating: JP Sales      3
No Rating: EU Sales      1
Name: count, dtype: int64

games_2[(games_2['rating'].isna()) & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))]

# Let's change some known T-rated games
display(games_2[(games_2['name'].str.contains('combat', case = False, na= False)) & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'].isna())])
display(games_2[(games_2['name'].str.contains('twisted metal', case = False, na= False))])
display(games_2[(games_2['name'].str.contains('road rash', case = False, na= False))])

# First change the combat named games
combat = (games_2['name'].str.contains('combat', case = False, na= False)) & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available'])) & (games_2['rating'].isna())
games_2.loc[combat,['rating']] = 'T'


# M
# Deathrow: Underground Team Combat - need to be changed to M
death = games_2['name'] == 'Deathrow: Underground Team Combat'
games_2.loc[death,['rating']] = 'M'

games_2[games_2['name'] == 'Deathrow: Underground Team Combat']


# Continue with known T rated games
twisted = (games_2['name'].str.contains('twisted metal', case = False, na= False)) & (games_2['rating'].isna())
games_2.loc[twisted,['rating']] = 'T'
display(games_2[games_2['name'].str.contains('twisted metal', case = False, na= False)])

# Continue with known T rated games
road = (games_2['name'].str.contains('road rash', case = False, na= False))
games_2.loc[road,['rating']] = 'T'

games_2[games_2['name'].str.contains('road rash', case = False, na= False)]

games_2[(games_2['rating'].isna()) & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))]

games_2['genre'].value_counts()

# Let's look at Racing games
racing = games_2[(games_2['rating'].notna()) & (games_2['genre'] == 'Racing') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))]
display(racing)

pre_racing = games_2[(games_2['rating'].notna()) & (games_2['genre'] == 'Racing') & (games_2['esrb_era'].isin(['pre-(EC,E10+)']))]

all_racing = games_2[(games_2['rating'].notna()) & (games_2['genre'] == 'Racing') & (games_2['esrb_era'].isin(['All Available']))]

display(games_2[(games_2['rating'].isna()) & (games_2['genre'] == 'Racing') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))])

display(racing['rating'].value_counts())
display(pre_racing['rating'].value_counts())
display(all_racing['rating'].value_counts())

# Racing is comprised of mostly 'E' rated games

# All simpson games are rated 'T'
games_2[games_2['name'].str.contains('simpson', case = False, na=False)]
simp = games_2['name'].str.contains('simpson', case = False, na=False)
games_2.loc[simp,['rating']] = 'T'


# All South Park Games are rated M
games_2[games_2['name'].str.contains('south park', case = False, na=False)]
sp = games_2['name'].str.contains('south park', case = False, na=False)
games_2.loc[sp,['rating']] = 'M'

# The 2015 need for speed is rated 'T'
#games_2[games_2['name'].str.contains('need for speed (2015)', case = False, na=False)].head(60)
games_2[games_2['name'] == "Need for Speed (2015)"]
speed_15 = games_2['name'] == "Need for Speed (2015)"
games_2.loc[speed_15,['rating']] = 'T'

# Neef for Speed: Shift 2 Unleashed is E10+, Most wanted is mislabeled as a T rating
#Need for Speed: Shift 2 Unleashed
#Need for Speed: Most Wanted
games_2[games_2['name'].isin(['Need for Speed: Shift 2 Unleashed','Need for Speed: Most Wanted','Need for Speed: Shift','Need for Speed: ProStreet',
                              'PGR3 - Project Gotham Racing 3'])]
speed_e10 = games_2['name'].isin(['Need for Speed: Shift 2 Unleashed','Need for Speed: Most Wanted','Need for Speed: Shift','Need for Speed: ProStreet',
                                  'PGR3 - Project Gotham Racing 3'])
games_2.loc[speed_e10,['rating']] = 'E10+'
display(games_2[games_2['name'].isin(['Need for Speed: Shift 2 Unleashed','Need for Speed: Most Wanted','Need for Speed: Shift','Need for Speed: ProStreet',
                                      'PGR3 - Project Gotham Racing 3'])])

# midnight club games
mc = (games_2['name'].str.contains('midnight club 3', case = False, na= False))
games_2.loc[mc,['rating']] = 'E10+'


mcs = (games_2['name'].str.contains('midnight club: street', case = False, na= False))
games_2.loc[mcs,['rating']] = 'E'

# Destruction Derby
dd = (games_2['name'].str.contains('destruction derby', case = False, na= False))
games_2.loc[dd,['rating']] = 'T'


# Dukes of Hazzard
dh = (games_2['name'].str.contains('dukes of', case = False, na= False))
games_2.loc[dh,['rating']] = 'T'

# Cars 2 is rated E10+
cars = games_2['name'] == 'Cars 2'
games_2.loc[cars,['rating']] = 'E10+'

# Starsky and Hutch
starsky = games_2['name'].str.contains('starsky', case = False, na= False)
games_2.loc[starsky,['rating']] = 'T'

#srs
srs = (games_2['name'].str.contains('srs', case = False, na= False))
games_2.loc[srs,['rating']] = 'T'


# mini-yonku
mini = (games_2['name'].str.contains('mini-yonku', case = False, na=False))
games_2.loc[mini,['rating']] = 'No Rating: JP Sales'

# yattaman
yatta = (games_2['name'].str.contains('yattaman', case = False, na=False))
games_2.loc[yatta,['rating']] = 'No Rating: JP Sales'


# sonic all transformed
sonic = (games_2['name'].str.contains('sonic & all', case = False, na= False))
games_2.loc[sonic,['rating']] = 'E10+'

# vin diesel
vin = (games_2['name'].str.contains('vin diesel', case = False, na= False))
games_2.loc[vin,['rating']] = 'T'


# totaled and toca
t = (games_2['name'].str.contains('Toca', case = False, na= False)) & (games_2['rating'].isna()) 
games_2.loc[t,['rating']] = 'T'


to = games_2['name'] == 'Totaled!'
games_2.loc[to,['rating']] = 'T'

# No rating: JP Sales

nr = (games_2['name'].str.contains('option', case = False, na= False)) | (games_2['name'].str.contains('motor toon', case = False, na= False)) | (games_2['name'].str.contains('wangan', case = False, na= False))
games_2.loc[nr,['rating']] = 'No Rating: JP Sales'

# Running Wild
rw = games_2['name'] == 'Running Wild'
games_2.loc[rw,['rating']] = 'T'


# We have made enough changes to the Racing genre to safely assume that the rest of the data is most likely going to fall in the E rated section
racing_esrb = (games_2['rating'].isna()) & (games_2['genre'] == 'Racing') & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))
games_2.loc[racing_esrb,['rating']] = 'E'

rating
E                              617
T                              193
E10+                           102
M                               20
No Rating: EU Sales              2
No Rating: EU + Other Sales      1
Name: count, dtype: int64

rating
E    260
T    111
M      5
Name: count, dtype: int64

rating
E                              357
E10+                           102
T                               82
M                               15
No Rating: EU Sales              2
No Rating: EU + Other Sales      1
Name: count, dtype: int64

# The missing rating for the DDR games will be counted as 'E'
ddr = (games_2['name'].str.contains("Dance Dance", case = False, na= False)) & (games_2['rating'].isna())
games_2.loc[ddr,['rating']] = 'E'


isna = games_2[(games_2['rating'].notna()) & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))]

isna['rating'].value_counts()

rating
E                              4682
T                              3165
M                              1679
E10+                           1504
EC                              213
No Rating: JP Sales              51
No Rating: EU Sales              19
No Rating: EU + Other Sales       9
No Rating: EU + JP Sales          3
Name: count, dtype: int64

display(games_2[games_2['year_of_release']< 1993])

# Let's look at the pre-ESRB era

# Change the name to No Rating
no_rating = (games_2['rating'].isna()) & (games_2['esrb_era'] == 'pre-ERSB')
games_2.loc[no_rating,['rating']] = 'No Rating: Pre-ESRB'

display(games_2[games_2['rating'] == 'No Rating: Pre-ESRB'])

# Clean up the ratings column, the games that are country exclusive
exclusive = games_2['rating'].isin(['No Rating: JP Sales','No Rating: EU Sales','No Rating: EU + Other Sales','No Rating: EU + JP Sales'])
games_2.loc[exclusive,['rating']] = 'No Rating: Country Exclusive'

display(games_2[games_2['rating'] == 'No Rating: Country Exclusive'])



games_2['rating'].value_counts()

rating
E                               4706
T                               3169
M                               1682
E10+                            1512
No Rating: Pre-ESRB              346
EC                               214
No Rating: Country Exclusive      84
Name: count, dtype: int64

# Look at the data

display(games_2[(games_2['rating'].isna()) & (games_2['esrb_era'].isin(['pre-(EC,E10+)','All Available']))])

games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              11713 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

# display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    # & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.1)].head(60))

# Look at possible country exclusive games

# T 
# Street Fighter
# The King of Fighters '96	
ts = games_2['name'].isin(['Street Fighter', "The King of Fighters '96"])
games_2.loc[ts,['rating']] = 'T'

# E
# Final Fantasy VI
ff = games_2['name'] == 'Final Fantasy VI'
games_2.loc[ff,['rating']] = 'E'

# Change the rest to country exclusive
ce = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.1)

games_2.loc[ce,['rating']] = 'No Rating: Country Exclusive'

#display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    #& (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.2)])


# There are no NaN that match the above box labeled all available
# Let's try less than 200,000

# First, look at the Final Fantasy games
# Get rid of the one that are country exclusive
games_2[games_2['name'].isin(['Dragon Quest & Final Fantasy in Itadaki Street Portable','Final Fantasy X-2: International + Last Mission',
                              'Final Fantasy X-2: International + Last Mission','Final Fantasy X International','Final Fantasy XII International Zodiac Job System',
                              'Dissidia: Final Fantasy Universal Tuning'])]

country = games_2['name'].isin(['Dragon Quest & Final Fantasy in Itadaki Street Portable','Final Fantasy X-2: International + Last Mission',
                              'Final Fantasy X-2: International + Last Mission','Final Fantasy X International','Final Fantasy XII International Zodiac Job System',
                                'Dissidia: Final Fantasy Universal Tuning'])
games_2.loc[country,['rating']] = 'No Rating: Country Exclusive'

ws = games_2['platform'] == 'WS'
games_2.loc[ws,['rating']] = 'No Rating: Country Exclusive'

# Final Fantasy I - VI is rated E
games_2[(games_2['name'].str.contains('final fantasy X', case = False, na= False)) & ~(games_2['rating'] == 'No Rating: Country Exclusive') & ~(games_2['platform'] == 'DS') & (games_1['year_of_release'] > 1993)] 
final_t = (games_2['name'].str.contains('final fantasy X', case = False, na= False)) & ~(games_2['rating'] == 'No Rating: Country Exclusive') & ~(games_2['platform'] == 'DS') & (games_1['year_of_release'] > 1993)
games_2.loc[final_t,['rating']] = 'T'

# and NOT Final Fantasy XII: Revenant Wings		
#


f1 = (games_2['name'].str.contains('final fantasy I &', case = False, na= False))
games_2.loc[f1,['rating']] = 'E'


games_2[(games_2['name'].str.contains('final fantasy type', case = False, na= False)) & ~(games_2['platform'] == 'PSP')]
f0 = (games_2['name'].str.contains('final fantasy type', case = False, na= False)) & ~(games_2['platform'] == 'PSP')
games_2.loc[f0,['rating']] = 'M'


t0 = (games_2['name'].str.contains('final fantasy type', case = False, na= False)) & (games_2['rating'].isna())
games_2.loc[t0,['rating']] = 'No Rating: Country Exclusive'


fv = (games_2['name'].str.contains('final fantasy VII', case = False, na= False))
games_2.loc[fv,['rating']] = 'T'


ff = (games_2['name'].str.contains('final fantasy', case = False, na= False)) & (games_2['rating'].isna())
games_2.loc[ff,['rating']] = 'E'




games_2[(games_2['name'].str.contains('final fantasy', case = False, na= False))]

#display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    #& (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.2)])


# There are no NaN that match the above box labeled all available
# Let's try less than 200,000

# Lets look at NG games
ng = (games_2['platform'] == 'NG') & (games_2['year_of_release'] > 1993)
games_2.loc[ng,['rating']] = 'No Rating: Country Exclusive'
games_2[(games_2['platform'] == 'NG') & (games_2['year_of_release'] > 1993)]

# lets look at the king of fighters games
kf = (games_2['name'].str.contains('king of fighters', case = False, na= False)) & (games_2['rating'].isna())
games_2.loc[kf,['rating']] = 'T'


# Resident Evil games are rated M
re = (games_2['name'].str.contains('resident evil', case = False, na= False))
games_2.loc[re,['rating']] = 'M'
games_2[(games_2['name'].str.contains('resident evil', case = False, na= False))]

# Input more titles into the correct locations

# E
# ['Gallop Racer','Gallop Racer 2000','Klonoa: Door to Phantomile','Klonoa: Door to Phantomile','StarBlade α','Cyber Sled','Namco Soccer Prime Goal']
gal = games_2['name'].isin(['Gallop Racer','Gallop Racer 2000','Klonoa: Door to Phantomile','Klonoa: Door to Phantomile','StarBlade α','Cyber Sled','Namco Soccer Prime Goal'])
games_2.loc[gal,['rating']] = 'E'
games_2[games_2['name'].isin(['Gallop Racer','Gallop Racer 2000','Klonoa: Door to Phantomile','Klonoa: Door to Phantomile','StarBlade α','Cyber Sled','Namco Soccer Prime Goal'])]


# T
# ['Shaman King: Spirit of Shamans', 'Fire ProWrestling G','Gundam: The Battle Master','Gouketuji Ichizoku 2: Chottodake Saikyou Densetsu']
sha = games_2['name'].isin(['Shaman King: Spirit of Shamans', 'Fire ProWrestling G','Gundam: The Battle Master','Gouketuji Ichizoku 2: Chottodake Saikyou Densetsu'])
games_2.loc[sha,['rating']] = 'T'
games_2[games_2['name'].isin(['Shaman King: Spirit of Shamans', 'Fire ProWrestling G','Gundam: The Battle Master','Gouketuji Ichizoku 2: Chottodake Saikyou Densetsu'])]

# M
# ['Metal Gear Solid Integral','D']
mg = games_2['name'].isin(['Metal Gear Solid Integral','D'])
games_2.loc[mg,['rating']] = 'M'
games_2[games_2['name'].isin(['Metal Gear Solid Integral','D'])]

so = games_2['name'].str.contains('metal gear solid:', case = False, na= False) & (games_2['rating'].isna())
games_2.loc[so,['rating']] = 'M'

# T Metal Gear
tg = (games_2['name'].str.contains('metal gear', case = False, na= False)) & (games_2['rating'].isna())
games_2.loc[tg,['rating']] = 'T'
games_2[(games_2['name'].str.contains('metal gear', case = False, na= False))]

display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.2)])



# Let's try less than 200,000
g200 = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.2)
games_2.loc[g200,['rating']] = 'No Rating: Country Exclusive'

display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 0.2)])

# Most of these games that made less than 1 million are not rated due to country exclusivity

#display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    #& (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 1.0)])


gm = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 1.0)
games_2.loc[gm,['rating']] = 'No Rating: Country Exclusive'


display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] <= 1.0)])

# Look at games over 1 million in the pre EC and EC10+ era
display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] >= 1)])

#T 
# Arc the Lad
e = games_2['name'].str.contains('dragon warrior', case = False, na = False) & ~(games_2['platform'].isin(['PS','DS']))
games_2.loc[e,['rating']] = 'E'

games_2[(games_2['name'].str.contains('arc the lad', case = False, na = False))]
atl = (games_2['name'].str.contains('arc the lad', case = False, na = False))
games_2.loc[atl,['rating']] = 'T'


#T 
# Tomagachi on GB - E
games_2[(games_2['name'].str.contains('tamagotchi', case = False, na = False))]
tgi = (games_2['name'].str.contains('tamagotchi', case = False, na = False))
games_2.loc[tgi,['rating']] = 'E'




# E 
# Chocobo
cho = (games_2['name'].str.contains('chocobo no', case = False, na = False))
games_2.loc[cho,['rating']] = 'No Rating: Country Exclusive'
display(games_2[(games_2['name'].str.contains('chocobo', case = False, na = False))])

cho = (games_2['name'].str.contains('chocobo to', case = False, na = False))
games_2.loc[cho,['rating']] = 'No Rating: Country Exclusive'
display(games_2[(games_2['name'].str.contains('chocobo', case = False, na = False))])

chod = (games_2['name'].str.contains("chocobo's dungeon 2", case = False, na = False))
games_2.loc[chod,['rating']] = 'E'
display(games_2[(games_2['name'].str.contains('chocobo', case = False, na = False))])



# Remaining are Not rated:
nr = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] >= 1)

games_2.loc[nr,['rating']] = 'No Rating: Country Exclusive'

display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    & (games_2['esrb_era'] == 'pre-(EC,E10+)') & (games_2['total_sales'] >= 1)])

games_2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              11987 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

# See the games in the 'All available' ESRP group

display(games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) 
    & (games_2['esrb_era'] == 'All Available') & (games_2['total_sales'] >= 0)])

# ALl are not rated
gaa = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['other_sales'] > 0) & (games_2['jp_sales'] > 0) & (games_2['esrb_era'] == 'All Available') & (games_2['total_sales'] >= 0)

games_2.loc[gaa,['rating']] = 'No Rating: Country Exclusive'


# Look at the naruto games
un = (games_2['name'].str.contains('ultimate ninja', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[un,['rating']] = 'T'


games_2[(games_2['name'].str.contains('Naruto: Uzumaki', case = False, na = False))]
nau = (games_2['name'].str.contains('Naruto: Uzumaki', case = False, na = False))
games_2.loc[nau,['rating']] = 'T'


games_2[(games_2['name'].str.contains('Naruto: Ninja Destiny', case = False, na = False))]
nd = (games_2['name'].str.contains('Naruto: Ninja Destiny', case = False, na = False))
games_2.loc[nd,['rating']] = 'E10+'


games_2[(games_2['name'].str.contains('Naruto Shippuden 3D', case = False, na = False))]
n3d = (games_2['name'].str.contains('Naruto Shippuden 3D', case = False, na = False))
games_2.loc[n3d,['rating']] = 'E10+'


nce = (games_2['name'].str.contains('naruto', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[nce,['rating']] = 'No Rating: Country Exclusive'



# Look at the Kouchuu games
games_2[(games_2['name'].str.contains('kouchuu', case = False, na = False)) & (games_2['rating'].isna())]
nrk = (games_2['name'].str.contains('kouchuu', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[nrk,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['name'].str.contains('kouchuu', case = False, na = False))]

# PCFX was not very popular
pcfx = games_2['platform'] == 'PCFX'
games_2.loc[pcfx,['rating']] = 'No Rating: Country Exclusive'

# Create separate masks for each for more detail (E10+, T, M, E)

e10_mask = games_2[(games_2['rating'] == 'E10+')]
t_mask = games_2[games_2['rating'] == 'T']
m_mask = games_2[games_2['rating'] == 'M']
e_mask = games_2[games_2['rating'] == 'E']



#Created a mask

display(games_2['rating'].value_counts().sort_values())

display(e10_mask.groupby(['genre','era'])['rating'].count().sort_values())
display(t_mask.groupby(['genre','era'])['rating'].count().sort_values())
display(m_mask.groupby(['genre','era'])['rating'].count().sort_values())
display(e_mask.groupby(['genre','era'])['rating'].count().sort_values())

rating
EC                               212
No Rating: Country Exclusive     295
No Rating: Pre-ESRB              342
E10+                            1515
M                               1704
T                               3208
E                               4738
Name: count, dtype: int64

genre         era   
Platform      90's        1
Strategy      90's        1
Shooter       80's        1
Simulation    80's        1
              90's        3
Fighting      2010's      5
Role-Playing  90's        6
Simulation    2010's      8
Puzzle        2010's     14
Fighting      2000's     16
Puzzle        2000's     21
Strategy      2010's     26
Shooter       2000's     27
Role-Playing  2010's     28
Shooter       2010's     30
Adventure     2000's     35
Sports        2010's     38
Simulation    2000's     39
Adventure     2010's     42
Strategy      2000's     53
Racing        2010's     58
Platform      2010's     67
Sports        2000's     72
Misc          2000's     77
Racing        2000's     79
Platform      2000's     80
Role-Playing  2000's     85
Misc          2010's     97
Action        2000's    246
              2010's    257
Name: rating, dtype: int64

genre         era   
Misc          80's        1
Simulation    80's        1
Sports        90's        1
Puzzle        2010's      2
Misc          90's        2
Platform      90's        3
Strategy      90's        4
Puzzle        2000's      4
Adventure     90's        5
Platform      2010's      6
Shooter       90's        7
Simulation    90's        7
Racing        90's       19
Action        90's       19
Role-Playing  90's       21
Racing        2010's     22
Fighting      90's       23
Strategy      2010's     39
Adventure     2010's     39
Simulation    2010's     56
Platform      2000's     56
Sports        2010's     64
Shooter       2010's     77
Misc          2010's     81
Adventure     2000's     83
Strategy      2000's    128
Fighting      2010's    129
Simulation    2000's    136
Sports        2000's    141
Role-Playing  2010's    166
Misc          2000's    166
Racing        2000's    172
Fighting      2000's    254
Role-Playing  2000's    277
Action        2010's    280
Shooter       2000's    283
Action        2000's    433
Name: rating, dtype: int64

genre         era   
Racing        90's        1
Strategy      90's        1
Misc          90's        2
Fighting      90's        2
Simulation    2010's      2
              2000's      3
Platform      2000's      3
Role-Playing  90's        4
Racing        2010's      5
Adventure     90's        6
Shooter       90's        6
Strategy      2010's      7
Misc          2000's      7
              2010's      8
Action        90's       14
Racing        2000's     14
Sports        2000's     18
Strategy      2000's     18
Fighting      2010's     21
              2000's     33
Adventure     2000's     55
              2010's     55
Role-Playing  2000's     60
              2010's    114
Shooter       2010's    270
Action        2000's    316
Shooter       2000's    316
Action        2010's    343
Name: rating, dtype: int64

genre         era   
Fighting      90's        1
Puzzle        80's        1
Shooter       2010's      2
Action        80's        2
Role-Playing  80's        3
Shooter       90's        5
Adventure     90's        7
Action        90's        7
Platform      80's        7
Fighting      2000's      7
Strategy      90's       10
Misc          90's       14
Strategy      2010's     14
Platform      90's       15
Simulation    90's       16
Role-Playing  2010's     17
Sports        90's       17
Role-Playing  90's       20
Adventure     2010's     28
Shooter       2000's     43
Puzzle        90's       52
Strategy      2000's     56
Platform      2010's     58
Simulation    2010's     80
Role-Playing  2000's     83
Puzzle        2010's     99
Adventure     2000's    134
Action        2010's    135
Misc          2010's    147
Racing        90's      154
              2010's    156
Simulation    2000's    251
Platform      2000's    320
Action        2000's    322
Puzzle        2000's    325
Misc          2000's    332
Sports        2010's    354
Racing        2000's    543
Sports        2000's    898
Name: rating, dtype: int64

# Looks like most of the Sports genre is rated E, let's take a closer look at the missing values
games_2[(games_2['genre'] == 'Sports') & (games_2['rating'].isna())].head(60)


# Most WWE and TOny Hawk games are rated T
games_2[(games_2['name'].str.contains('WWE', case = False, na = False)) & games_2['rating'].isna()]
wwe = (games_2['name'].str.contains('WWE', case = False, na = False)) & games_2['rating'].isna()
games_2.loc[wwe,['rating']] = 'T'

games_2[(games_2['name'].str.contains('Tony Hawk', case = False, na = False)) & (games_2['rating'].isna())]
th = (games_2['name'].str.contains('Tony Hawk', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[th,['rating']] = 'T'

# The Wii, PS3, and X360 games labeled E are actually E10+
games_2[(games_2['name'].str.contains('Tony Hawk', case = False, na = False)) & (games_2['platform'].isin(['Wii','X360','PS3'])) & (games_2['rating'] == 'E')]
thw = (games_2['name'].str.contains('Tony Hawk', case = False, na = False)) & (games_2['platform'].isin(['Wii','X360','PS3'])) & (games_2['rating'] == 'E')
games_2.loc[thw,['rating']] = 'E10+'

#Tony Hawk's downhill jam is rated E
games_2[(games_2['name'].str.contains('Tony Hawk', case = False, na = False)) & (games_2['rating'] == 'E10+')]
thd = games_2['name'] == "Tony Hawk's Downhill Jam"
games_2.loc[thd,['rating']] = 'E'

# The Toney hawk games on the PS, N64, and GBA were rated E
games_2[(games_2['name'].str.contains("tony hawk's pro skater", case = False, na = False)) & (games_2['platform'].isin(['PS','N64','GBA','GB']))]
thpn = (games_2['name'].str.contains("tony hawk's pro skater", case = False, na = False)) & (games_2['platform'].isin(['PS','N64','GBA','GB']))
games_2.loc[thpn,['rating']] = 'E'


games_2[(games_2['name'].str.contains('Tony Hawk', case = False, na = False))]

#display(games_2[(games_2['genre'] == 'Sports') & (games_2['rating'].isna())].head(60))

# It appears that a lot of ['GB','GBA','N64','PS'] games were rated E, let's take a closer look


e10_mask = games_2[(games_2['rating'] == 'E10+')]
t_mask = games_2[games_2['rating'] == 'T']
m_mask = games_2[games_2['rating'] == 'M']
e_mask = games_2[games_2['rating'] == 'E']

e10_mask_g = games[(games['rating'] == 'E10+')]
t_mask_g = games[games['rating'] == 'T']
m_mask_g = games[games['rating'] == 'M']
e_mask_g = games[games['rating'] == 'E']

display(games_2['rating'].value_counts().sort_values())



display(e10_mask.groupby(['platform'])['rating'].count().sort_values())
display(t_mask.groupby(['platform'])['rating'].count().sort_values())
display(m_mask.groupby(['platform'])['rating'].count().sort_values())
display(e_mask.groupby(['platform'])['rating'].count().sort_values())

rating
EC                               212
No Rating: Country Exclusive     295
No Rating: Pre-ESRB              342
E10+                            1517
M                               1704
T                               3209
E                               4741
Name: count, dtype: int64

platform
2600      1
GEN       1
NES       1
PS        3
SNES      6
GBA      27
GC       32
XB       32
PSV      33
XOne     35
PS4      44
WiiU     46
3DS      84
PC       85
PSP     108
PS2     129
PS3     152
X360    182
Wii     248
DS      268
Name: rating, dtype: int64

platform
2600      1
SNES      1
SAT       6
DC       14
N64      15
WiiU     16
XOne     46
3DS      56
GBA      73
PSV      86
PS4     103
PS      121
DS      123
GC      175
PSP     213
Wii     225
XB      302
PC      311
X360    352
PS3     359
PS2     611
Name: rating, dtype: int64

platform
GB        1
GEN       1
SAT       1
DC        3
N64       4
GBA       7
3DS      12
DS       15
WiiU     18
PS       33
Wii      35
PSV      38
GC       41
PSP      55
XOne     92
PS4     105
XB      164
PS2     227
PC      269
PS3     278
X360    305
Name: rating, dtype: int64

platform
3DO       1
SCD       1
GEN       2
2600      2
DC        7
NES      12
SAT      20
SNES     25
PSV      26
GB       26
WiiU     40
XOne     49
PS4      58
N64      87
3DS     116
PC      175
PSP     210
PS3     229
GC      250
X360    263
XB      265
PS      279
GBA     465
Wii     552
PS2     598
DS      983
Name: rating, dtype: int64

# GB is the least controversial and is almost entirely E; lets look at any that are not E rated
games_2[(games_2['platform'] == 'GB')]

# It seems safe to give all GB games an E rating
gb = (games_2['platform'] == 'GB')
games_2.loc[gb,['rating']] = 'E'


# Let's look at the GBA games currently rated M
games_2[(games_2['platform'] == 'GBA') & (games_2['rating'] == 'M')]

# Most of these are actually rated 'T' except GTA
games_2[(games_2['platform'] == 'GBA') & (games_2['rating'] == 'M')]
tgb = (games_2['platform'] == 'GBA') & (games_2['rating'] == 'M')
games_2.loc[tgb,['rating']] = 'T'

# All GTA games are rated M
games_2[(games_2['name'].str.contains('grand theft', case = False, na = False))]


gta = (games_2['name'].str.contains('grand theft', case = False, na = False))
games_2.loc[gta,['rating']] = 'M'


#Let's look at the GBA games that are rated 'T'
games_2[(games_2['platform'] == 'GBA') & (games_2['rating'] == 'T')].head(60)

# Street Fighter II was rated E
sf = (games_2['name'] == 'Super Street Fighter II: Turbo Revival') & (games_2['platform'] == 'GBA')
games_2.loc[sf,['rating']] = 'E'


# Fear Factor Unleashed was rated E
ff = (games_2['name'] == 'Fear Factor: Unleashed') & (games_2['platform'] == 'GBA')
games_2.loc[ff,['rating']] = 'E'
  


# cabela and road rash GBA games were rated E
c = (games_2['name'].str.contains('cabela', case = False, na = False)) & (games_2['platform'] == 'GBA')
rr = (games_2['name'].str.contains('road rash', case = False, na = False)) & (games_2['platform'] == 'GBA')
games_2.loc[c,['rating']] = 'E'
games_2.loc[rr,['rating']] = 'E'

# There are more T rated games that should be rated E
eg = (games_2['name'].isin(['River City Ransom EX','The Pinball of the Dead','Double Dragon Advance','Boktai 2: Solar Boy Django','Broken Sword: The Shadow of the Templars'])) & (games_2['platform'] == 'GBA')
games_2.loc[eg,['rating']] = 'E'

yg = (games_2['name'] == "Yggdra Union: We'll Never Fight Alone") & (games_2['platform'] == 'GBA')
games_2.loc[yg,['rating']] = 'E10+'


# Let's look at the GBA games that are rated E10+; most of these are wrong so let's change them
games_2[(games_2['platform'] == 'GBA') & (games_2['rating'] == 'E10+')]

# T

ct = (games_2['name'].isin(['Star Wars Episode III: Revenge of the Sith',"Pirates of the Caribbean: Dead Man's Chest",'Power Rangers: S.P.D.','Shrek SuperSlam','Ultimate Spider-Man',
'Dragon Ball GT: Transformation','Naruto: Ninja Council','Teen Titans','Batman Begins','X-Men: The Official Game','Gunstar Super Heroes',
'Rebelstar: Tactical Command','Sigma Star Saga','Ty the Tasmanian Tiger 3: Night of the Quinkan','Dragon Ball: Advanced Adventure',
"Greg Hastings' Tournament Paintball Max'd",'Justice League Heroes: The Flash'])) & (games_2['platform'] == 'GBA')

games_2.loc[ct,['rating']] = 'T'


# E 
ce = (games_2['name'].isin(['Final Fantasy IV Advance','Final Fantasy VI Advance','Need for Speed: Most Wanted','Kong: The 8th Wonder of the World',
                            'Chicken Shoot 2'])) & (games_2['platform'] == 'GBA')

games_2.loc[ce,['rating']] = 'E'


# Let's look at the GBA that are NaN
games_2[(games_2['platform'] == 'GBA') & (games_2['rating'].isna())].head(60)

# The majoirty are going to be rated E, but some are not
e10g = (games_2['name'].isin(['Fantastic 4: Flame On'])) & (games_2['platform'] == 'GBA')
games_2.loc[e10g,['rating']] = 'E10+'

tga = (games_2['name'].isin(['Yu Yu Hakusho Ghost Files: Spirit Detective'])) & (games_2['platform'] == 'GBA')
games_2.loc[tga,['rating']] = 'T'

nor = (games_2['name'].isin(['Fire Emblem: Fuuin no Tsurugi'])) & (games_2['platform'] == 'GBA')
games_2.loc[nor,['rating']] = 'No Rating: Country Exclusive'

# Most title appear to be rated E on the GBA
gba = (games_2['platform'] == 'GBA') &  (games_2['rating'].isna())
games_2.loc[gba,['rating']] = 'E'

# Let's look at the original data
display(e10_mask_g.groupby(['platform'])['rating'].count().sort_values())
display(t_mask_g.groupby(['platform'])['rating'].count().sort_values())
display(m_mask_g.groupby(['platform'])['rating'].count().sort_values())
display(e_mask_g.groupby(['platform'])['rating'].count().sort_values())

platform
2600      1
GEN       1
NES       1
PS        3
SNES      6
GBA      26
PSV      30
GC       31
XB       31
XOne     33
PS4      41
WiiU     43
PC       76
3DS      80
PSP     106
PS2     127
PS3     144
X360    172
Wii     249
DS      269
Name: rating, dtype: int64

platform
2600      1
GB        1
SNES      1
SAT       2
N64       8
DC       11
WiiU     17
XOne     43
3DS      56
GBA      71
PSV      83
PS       83
PS4      96
DS      128
GC      171
PSP     207
Wii     226
XB      294
PC      303
X360    350
PS3     352
PS2     586
Name: rating, dtype: int64

platform
DC        1
GB        1
GEN       1
N64       1
SAT       1
GBA       7
DS       10
3DS      12
WiiU     18
PS       25
Wii      34
PSV      38
GC       39
PSP      54
XOne     86
PS4      98
XB      162
PS2     224
PC      263
PS3     275
X360    304
Name: rating, dtype: int64

platform
2600      1
GEN       1
NES       2
GB        3
DC        4
SAT       6
SNES      8
N64      14
PSV      23
WiiU     37
XOne     47
PS4      55
3DS     100
PS      132
PC      150
PSP     191
PS3     219
GC      240
X360    253
XB      255
GBA     441
Wii     513
PS2     565
DS      892
Name: rating, dtype: int64

# Let's look at the GEN data
games_2[(games_2['platform'] == 'GEN')]


# Mortal combat was officially rated M on the GEN
games_2[(games_2['name'].str.contains('mortal kombat', case = False, na = False)) &(games_2['platform'] == 'GEN')]
mk = (games_2['name'].str.contains('mortal kombat', case = False, na = False)) & (games_2['platform'] == 'GEN')
games_2.loc[mk,['rating']] = 'M'

games_2[(games_2['platform'] == 'GEN')]

# Castlevania Bloodlines was rated T

gn = (games_2['name'].str.contains('castlevania', case = False, na = False)) & (games_2['rating'].isna()) & (games_2['platform'].isin(['GEN','N64']))
games_2.loc[gn,['rating']] = 'T'

gn = (games_2['name'].str.contains('castlevania', case = False, na = False)) & (games_2['rating'].isna()) & (games_2['platform'].isin(['SNES']))
games_2.loc[gn,['rating']] = 'E'

gn = (games_2['name'].str.contains('castlevania', case = False, na = False)) & (games_2['rating'].isna()) 
games_2.loc[gn,['rating']] = 'M'

games_2[(games_2['name'].str.contains('castlevania', case = False, na = False))]

# Continue with the GEN data
games_2[(games_2['platform'] == 'GEN')]

gen = (games_2['platform'] == 'GEN') & (games_2['rating'].isna()) & (games_2['total_sales'] > 0.1)
games_2.loc[gen,['rating']] = 'E'

gen = (games_2['platform'] == 'GEN') & (games_2['rating'].isna())
games_2.loc[gen,['rating']] = 'No Rating: Country Exclusive'

# Look at NES platform
zelda_og = games_2['name'].isin(['The Legend of Zelda','Zelda II: The Adventure of Link'])
games_2.loc[zelda_og,['rating']] = 'E'

games_2[(games_2['platform'] == 'NES') & (games_2['rating'] == 'E10+')]

ff = (games_2['platform'] == 'NES') & (games_2['rating'] == 'E10+')
games_2.loc[ff,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['platform'] == 'NES') & (games_2['rating'].isna())]

games_2[(games_2['platform'] == 'SNES')]

# Killer Instinct games were rated T
ki = (games_2['name'].str.contains('Killer Instinct', case = False, na = False))
games_2.loc[ki,['rating']] = 'T'

games_2[(games_2['platform'] == 'SNES') & (games_2['rating'].isna()) & (games_2['total_sales'] >= 1)]

# Mortal Kombat 3 games are rated M
mk = (games_2['name'].str.contains('Mortal Kombat 3', case = False, na = False))
games_2.loc[mk,['rating']] = 'M'


#Some titles in the SNES category are country exclusive
games_2[(games_2['name'].str.contains('Derby Stallion', case = False, na = False))]
ds = (games_2['name'].str.contains('Derby Stallion', case = False, na = False))
games_2.loc[ds,['rating']] = 'No Rating: Country Exclusive'


ce = games_2['name'].isin(['Dragon Quest VI: Maboroshi no Daichi','Dragon Quest III: Soshite Densetsu e...'])
games_2.loc[ce,['rating']] = 'No Rating: Country Exclusive'

se = (games_2['platform'] == 'SNES') & (games_2['rating'].isna()) & (games_2['total_sales'] >= 1)
games_2.loc[se,['rating']] = 'E'



# The Simulation games appear to be No Rating
games_2[(games_2['platform'] == 'SNES') & (games_2['genre'] == 'Simulation') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)].head(60)
sim = (games_2['platform'] == 'SNES') & (games_2['genre'] == 'Simulation') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)
games_2.loc[sim,['rating']] = 'No Rating: Country Exclusive'

# Look at the Sports games
games_2[(games_2['platform'] == 'SNES') & (games_2['genre'] == 'Sports') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)].head(60)

# International Superstar Soccer is rated E
games_2[(games_2['name'].str.contains('International Superstar', case = False, na = False))]
ins = (games_2['name'].str.contains('International Superstar', case = False, na = False))
games_2.loc[ins,['rating']] = 'E'


# Kirby's dream house is rated E
games_2[(games_2['name'].str.contains("kirby's", case = False, na = False)) & (games_2['platform'] != 'Wii')]
kw = (games_2['name'].str.contains("kirby's", case = False, na = False)) & (games_2['platform'] != 'Wii')
games_2.loc[kw,['rating']] = 'E'

# J-League games were Japan only
games_2[(games_2['name'].str.contains("j-league", case = False, na = False))]
jl = (games_2['name'].str.contains("j-league", case = False, na = False))
games_2.loc[jl,['rating']] = 'No Rating: Country Exclusive'

# Jikkyou games before 2007 were country specific
games_2[(games_2['name'].str.contains("Jikkyou", case = False, na = False)) & (games_2['year_of_release'] < 2007)]
jik = (games_2['name'].str.contains("Jikkyou", case = False, na = False)) & (games_2['year_of_release'] < 2007)
games_2.loc[jik,['rating']] = 'No Rating: Country Exclusive'

# The rest of the SNES Sports games are country specific
games_2[(games_2['platform'] == 'SNES') & (games_2['genre'] == 'Sports') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)].head(60)
sps = (games_2['platform'] == 'SNES') & (games_2['genre'] == 'Sports') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)
games_2.loc[sps,['rating']] =  'No Rating: Country Exclusive'


# Look at the strategy games for the SNES
games_2[(games_2['platform'] == 'SNES') & (games_2['genre'] == 'Strategy') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)]

# Romance of the Three Kingdoms is rated E
games_2[(games_2['name'].str.contains('Romance of the Three Kingdoms', case = False, na = False)) & (games_2['year_of_release'] <= 2001)]
rok = (games_2['name'].str.contains('Romance of the Three Kingdoms', case = False, na = False)) & (games_2['year_of_release'] <= 2001)
games_2.loc[rok,['rating']] = 'E'



# The rest of the strategy games are not rated
stn = (games_2['platform'] == 'SNES') & (games_2['genre'] == 'Strategy') & (games_2['rating'].isna()) & (games_2['total_sales'] <= 1)
games_2.loc[stn,['rating']] = 'No Rating: Country Exclusive'


# Look at the rest of the SNES games
games_2[(games_2['platform'] == 'SNES') & (games_2['rating'].isna())].head(60)


# Look at the Space Invaders games
games_2[(games_2['name'].str.contains('Space Invaders', case = False, na = False))]
si = (games_2['name'].str.contains('Space Invaders', case = False, na = False))
games_2.loc[si,['rating']] = 'E'


# All remaining stree fighter games are rated T
sfg = (games_2['name'].str.contains('street fighter', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[sfg,['rating']] = 'T'
games_2[(games_2['name'].str.contains('street fighter', case = False, na = False))]


# ['EarthBound','Mega Man 7','RockMan & Forte'] are rated E
eb = games_2['name'].isin(['EarthBound','Mega Man 7','RockMan & Forte'])
games_2.loc[eb,['rating']] = 'E'
games_2[games_2['name'].isin(['EarthBound','Mega Man 7','RockMan & Forte'])]


# Saturday Night Slam Masters is rated T
snsm = games_2['name'] == 'Saturday Night Slam Masters'
games_2.loc[snsm,['rating']] = 'T'
games_2[games_2['name'] == 'Saturday Night Slam Masters']


# Wizardry VI is rated M on the PC, but not the SNES; so, all other games are not rated
games_2[(games_2['platform'] == 'SNES') & (games_2['rating'].isna())]
snr = (games_2['platform'] == 'SNES') & (games_2['rating'].isna())
games_2.loc[snr,['rating']] = 'No Rating: Country Exclusive'

games_2[games_2['platform'] == 'SNES']

# Look at the SAT games
games_2[(games_2['platform'] == 'SAT')]
games_2[(games_2['platform'] == 'SAT') & (games_2['platform'] == 'SAT')]

# Virtua fighting, shooter, and R-P games are all rated T
virtuat = (games_2['name'].str.contains('virtua ', case = False, na = False)) & (games_2['genre'].isin(['Fighting','Shooter','Role-Playing']))
games_2.loc[virtuat,['rating']] = 'T'


# All virtua sports and racing games before 2005 are rated E
virtuas = (games_2['name'].str.contains('virtua ', case = False, na = False)) & (games_2['platform'] != 'PS2') & (games_2['rating'].isna()) & (games_2['genre'].isin(['Sports','Racing']))
games_2.loc[virtuas,['rating']] = 'E'


# The rest of the virtua games are not rated
virtuanr = (games_2['name'].str.contains('virtua ', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[virtuanr,['rating']] = 'No Rating: Country Exclusive'
games_2[(games_2['name'].str.contains('virtua ', case = False, na = False)) & (games_2['rating'].isna())]

# Some sports games are not rated
games_2[(games_2['platform'] == 'SAT') & (games_2['jp_sales'] >= 0.12) & (games_2['jp_sales'] <= 0.25) & (games_2['genre'].isin(['Sports','Racing'])) & (games_2['rating'].isna())]
snr = (games_2['platform'] == 'SAT') & (games_2['jp_sales'] >= 0.12) & (games_2['jp_sales'] <= 0.25) & (games_2['genre'].isin(['Sports','Racing'])) & (games_2['rating'].isna())
games_2.loc[snr,['rating']] = 'No Rating: Country Exclusive'


# The rest of the Sports games are rated E
spe = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Sports','Racing'])) & (games_2['rating'].isna())
games_2.loc[spe,['rating']] = 'E'

games_2[(games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Fighting','Shooter'])) & (games_2['rating'].isna())]

# ALL SAT mobile suit games are not rated
msg = (games_2['name'].str.contains('mobile suit ', case = False, na = False)) & (games_2['platform'] == 'SAT')
games_2.loc[msg,['rating']] = 'No Rating: Country Exclusive'

# T
# ['Guardian Heroes','Panzer Dragoon Saga','Lunar 2: Eternal Blue'] - these R-P games are T and the rest are not rated
trp = (games_2['platform'] == 'SAT') & (games_2['name'].isin(['Guardian Heroes','Panzer Dragoon Saga','Lunar: Silver Star Story']))
games_2.loc[trp,['rating']] = 'T'


# The rest of the R-P games are not rated
sanr = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Role-Playing'])) & (games_2['rating'].isna())
games_2.loc[sanr,['rating']] = 'No Rating: Country Exclusive'

# Rated T in strategy category
stf = (games_2['platform'] == 'SAT') & (games_2['name'].isin(['Shining Force III']))


# None of the Adventure, Misc, or strategy SAT games are rated
saa = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Adventure','Misc','Strategy'])) & (games_2['rating'].isna())
games_2.loc[saa,['rating']] = 'No Rating: Country Exclusive'

# Mega Man 8 Anniversary Collector's Edition is not rated
mm = (games_2['platform'] == 'SAT') & (games_2['name'] == "Mega Man 8 Anniversary Collector's Edition")
games_2.loc[mm,['rating']] = 'No Rating: Country Exclusive'

# The rest of the platform games are rated E
plt = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Platform'])) & (games_2['rating'].isna())
games_2.loc[plt,['rating']] = 'E'

# Not rated
# ['Galactic Attack','Parodius']
noshoo = (games_2['platform'] == 'SAT') & (games_2['name'].isin(['Galactic Attack','Parodius']))
games_2.loc[noshoo,['rating']] = 'No Rating: Country Exclusive'

# Shooter games above 0.13 in ts are rated T
satf = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Shooter'])) & (games_2['total_sales'] >= 0.13) & (games_2['rating'].isna()) | (games_2['name'] == 'Gunbird')
games_2.loc[satf,['rating']] = 'T'

# The rest of the Shooter games are not rated
nrshoo = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Shooter'])) & (games_2['rating'].isna())
games_2.loc[nrshoo,['rating']] = 'No Rating: Country Exclusive'

# Look at the Fighting games
tfight = (games_2['platform'] == 'SAT') & (games_2['genre'].isin(['Fighting'])) & (games_2['total_sales'] >= 0.13) & (games_2['rating'].isna()) | (games_2['name'] == 'Golden Axe: The Duel') | (games_2['name'] == 'Marvel Super Heroes')
games_2.loc[tfight,['rating']] = 'T'

# Gun Griffon is rated T
gg = (games_2['platform'] == 'SAT') & (games_2['name'] == 'GunGriffon')
games_2.loc[gg,['rating']] = 'T'

# The rest of the games are not rated
nrfight = (games_2['platform'] == 'SAT') & (games_2['rating'].isna())
games_2.loc[nrfight,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['platform'] == 'SAT') & (games_2['rating'].isna())]

# Look at DC games
# games with na_sales are rated E
nadc = (games_2['platform'] == 'DC') & (games_2['na_sales'] > 0) & (games_2['rating'].isna()) | (games_2['name'] == 'NBA 2K')
games_2.loc[nadc,['rating']] = 'E'


# games with total sales between 0.11 and 0.14 are rated T
tsdc = (games_2['platform'] == 'DC') & (games_2['total_sales'] >= 0.11) & (games_2['total_sales'] <= 0.14) & (games_2['rating'].isna()) | (games_2['name'] == 'Capcom vs. SNK: Millennium Fight 2000 Pro')
games_2.loc[tsdc,['rating']] = 'T'


# ALL house of the dead games are rated M
hod = (games_2['name'].str.contains('The House of the Dead', case = False, na = False))
games_2.loc[hod,['rating']] = 'M'


# The rest of the DC games are not rated
dcnr = (games_2['platform'] == 'DC') & (games_2['rating'].isna())
games_2.loc[dcnr,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['platform'] == 'DC') & (games_2['rating'].isna())]

# Look at the N64 games
games_2[(games_2['platform'] == 'N64')]
games_2[(games_2['platform'] == 'N64') & (games_2['rating'].isna())]


# All ready 2 rumble games are rated T
rtr = (games_2['name'].str.contains('ready 2 rumble', case = False, na = False))
games_2.loc[rtr,['rating']] = 'T'
games_2[(games_2['name'].str.contains('ready 2 rumble', case = False, na = False))]


# Itoi Shigesato no Bass Tsuri No. 1 Ketteihan!	and the chou game are not rated
it = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Sports'])) & (games_2['rating'].isna()) & (games_2['name'] == 'Itoi Shigesato no Bass Tsuri No. 1 Ketteihan!')
tsg = (games_2['name'].str.contains('Chou-Kuuka', case = False, na = False))
games_2.loc[it,['rating']] = 'No Rating: Country Exclusive'
games_2.loc[tsg,['rating']] = 'No Rating: Country Exclusive'


# Look at the sport games
games_2[(games_2['platform'] == 'N64') & (games_2['genre'].isin(['Sports'])) & (games_2['rating'].isna())]

# The rest of the sports games are rated E
nsport = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Sports'])) & (games_2['rating'].isna())
games_2.loc[nsport,['rating']] = 'E'

# Look at the missing fightin N64 games

# Super smash bros. is rated E
ssb = games_2['name'] == 'Super Smash Bros.'
games_2.loc[ssb,['rating']] = 'E'

# The other NaN smash bros. is rated E10+
essb = (games_2['name'].str.contains('super smash bros', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[essb,['rating']] = 'E10+'

# The tom and Jerry game is rated E, but not all of them are rated T
tj = (games_2['name'].str.contains('tom and jerry in war', case = False, na = False))
games_2.loc[tj,['rating']] = 'T'

tjf = games_2['name'] == 'Tom and Jerry in Fists of Furry'
games_2.loc[tjf,['rating']] = 'E'

# The other NaN games in the fighting category are rated T
nfight = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Fighting'])) & (games_2['rating'].isna())
games_2.loc[nfight,['rating']] = 'T'


# Look at shooter games
games_2[(games_2['platform'] == 'N64') & (games_2['genre'].isin(['Shooter'])) & (games_2['rating'].isna())]

# Turok evolutin games are T and the rest of the series is M
turev = (games_2['name'].str.contains('turok: ev', case = False, na = False))
games_2.loc[turev,['rating']] = 'T'

turm = (games_2['name'].str.contains('turok', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[turm,['rating']] = 'M'


# The doom games are all rated M except the one on the GBA
doom = (games_2['name'].str.contains('doom ', case = False, na = False)) & (games_2['platform'] != 'GBA')
games_2.loc[doom,['rating']] = 'M'
games_2[(games_2['name'].str.contains('doom ', case = False, na = False))]

doomg = (games_2['name'].str.contains('doom ', case = False, na = False)) & (games_2['platform'] == 'GBA')
games_2.loc[doomg,['rating']] = 'T'


# All quake games are rated M
quake = (games_2['name'].str.contains('Quake', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[quake,['rating']] = 'M'

# ALl Hexen games are rated M
hexen = (games_2['name'].str.contains('Hexen', case = False, na = False))
games_2.loc[hexen,['rating']] = 'M'

# E rated shooter games
eshoo = games_2['name'].isin(['Star Fox 64','Asteroids Hyper 64','Knife Edge: NoseGunner','Star Soldier: Vanishing Earth']) & (games_2['platform'] == 'N64')
games_2.loc[eshoo,['rating']] = 'E'

# T rated shooter games
tshoo = (games_2['name'].isin(["Tom Clancy's Rainbow Six",'Body Harvest','GoldenEye 007','Jet Force Gemini','Armorines: Project S.W.A.R.M.','Robotron 64'])) & (games_2['platform'] == 'N64')
games_2.loc[tshoo,['rating']] = 'T'

# M rated shooter games
mshoo = games_2['name'].isin(['Duke Nukem 64','Duke Nukem: Zero Hour']) & (games_2['platform'] == 'N64')
games_2.loc[mshoo,['rating']] = 'M'

#The remaining shooter game is not rated
nrshoo = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Shooter'])) & (games_2['rating'].isna())
games_2.loc[nrshoo,['rating']] = 'No Rating: Country Exclusive'


# Perfect Dark is M rated on every console
pd = (games_2['name'].str.contains('perfect dark', case = False, na = False))
games_2.loc[pd,['rating']] = 'M'

# Look at Strategy games

# T
# ['Command & Conquer','Starcraft 64']
tstrat = games_2['name'].isin(['Command & Conquer','Starcraft 64']) & (games_2['platform'] == 'N64')
games_2.loc[tstrat,['rating']] = 'T'

# E
# ['Pokémon Stadium 2','Battlezone: Rise of the Black Dogs','Worms Armageddon']
estrat = games_2['name'].isin(['Pokémon Stadium 2','Battlezone: Rise of the Black Dogs','Worms Armageddon']) & (games_2['platform'] == 'N64')
games_2.loc[estrat,['rating']] = 'E'

# Not Rated
# ['Pocket Monsters Stadium','Super Robot Taisen 64','PD Ultraman Battle Collection 64']
nrstrat = games_2['name'].isin(['Pocket Monsters Stadium','Super Robot Taisen 64','PD Ultraman Battle Collection 64']) & (games_2['platform'] == 'N64')
games_2.loc[nrstrat,['rating']] = 'No Rating: Country Exclusive'

# Look at Simulation games - all simulation games are rated E
simg = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Simulation'])) & (games_2['rating'].isna())
games_2.loc[simg,['rating']] = 'E'

# Look at platform games - all are rated E except for Conker's Bad Fur Day
conker = (games_2['name'].str.contains("conker", case = False, na = False))
games_2.loc[conker,['rating']] = 'M'


plat = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Platform'])) & (games_2['rating'].isna())
games_2.loc[plat,['rating']] =  'E'


# Look at Adventure games - ts above 0.7 are E rated, the rest are not rated
adv = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Adventure'])) & (games_2['total_sales'] >= 0.7) & (games_2['rating'].isna())
games_2.loc[adv,['rating']] = 'E'

rest = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Adventure']))  & (games_2['rating'].isna())
games_2.loc[rest,['rating']] = 'No Rating: Country Exclusive'

# Look at Miscellaneous games

# T 
tmisc = games_2['name'].isin(['California Speed','Golden Nugget 64'])
games_2.loc[tmisc,['rating']] = 'T'

# Not Rated
nrmisc = games_2['name'].isin(['Mahjong Master'])
games_2.loc[nrmisc,['rating']] = 'No Rating: Country Exclusive'

# EC Rated
ecmisc = (games_2['name'].isin(["Sesame Street: Elmo's Letter Adventure","Sesame Street: Elmo's Number Journey"]))
games_2.loc[ecmisc,['rating']] = 'EC'


# The rest are rated E
emisc = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Misc']))  & (games_2['rating'].isna())
games_2.loc[emisc,['rating']] = 'E'


# Look at the R-P games
# T
trp = (games_2['platform'] == 'N64') & (games_2['total_sales'] > 0.09) & (games_2['total_sales'] < 0.42) & (games_2['genre'].isin(['Role-Playing']))  & (games_2['rating'].isna())
games_2.loc[trp,['rating']] = 'T'

# The rest are E
erp = (games_2['platform'] == 'N64') & (games_2['genre'].isin(['Role-Playing']))  & (games_2['rating'].isna())
games_2.loc[erp,['rating']] = 'E'


# The remaining NaN value for the N64 are Action
# E
# Some of the ones with lower sales are rated E
ls = (games_2['platform'] == 'N64')  & (games_2['rating'].isna()) & (games_2['total_sales'] >= .16) & (games_2['total_sales'] <= .25)
games_2.loc[ls,['rating']] = 'E'
els = (games_2['platform'] == 'N64')  & (games_2['rating'].isna()) & (games_2['total_sales'] >= .03) & (games_2['total_sales'] <= .11)
games_2.loc[els,['rating']] = 'E'

# More E
# ['Blast Corps','Rugrats in Paris: The Movie','Scooby-Doo! Classic Creep Capers','Saban's Power Rangers: Lightspeed Rescue','Mystical Ninja starring Goemon']
me = (games_2['platform'] == 'N64')  & (games_2['rating'].isna()) & (games_2['name'].isin(['Blast Corps','Rugrats in Paris: The Movie',
                                                                                           'Scooby-Doo! Classic Creep Capers',
                                                                                           "Saban's Power Rangers: Lightspeed Rescue",
                                                                                           'Mystical Ninja starring Goemon',"The Legend of Zelda: Majora's Mask",
                                                                                          'The Legend of Zelda: Ocarina of Time','Superman: The New Superman Adventures']))
games_2.loc[me,['rating']] = 'E'

# M
mact = (games_2['platform'] == 'N64')  & (games_2['rating'].isna()) & (games_2['total_sales'] < 0.28)
games_2.loc[mact,['rating']] = 'M'


# The rest are rated T
tact = (games_2['platform'] == 'N64')  & (games_2['rating'].isna())
games_2.loc[tact,['rating']] = 'T'


games_2[(games_2['platform'] == 'N64')  & (games_2['rating'].isna())]

# Look at the missing values
games_2.info()

games_2['platform'].isnull().sum()

missing = games_2[games_2['rating'].isnull()]
display(missing)

missing_platform = missing.groupby('platform').size().sort_values()
display(missing_platform)

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              12850 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

platform
3DO       2
TG16      2
SCD       4
XOne     23
WiiU     26
GC       44
XB       58
PS4      79
PC      104
X360    158
3DS     246
PSV     246
Wii     247
PS3     307
DS      532
PS2     561
PSP     611
PS      611
dtype: int64

# Let's look at the platforms that are not missing many
games_2[games_2['platform'] == '3DO']

# 3DO games
do = (games_2['platform'] == '3DO') & (games_2['rating'].isna())
games_2.loc[do,['rating']] = 'No Rating: Country Exclusive'

# TG16 games
tg = games_2['platform'] == 'TG16'
games_2.loc[tg,['rating']] = 'No Rating: Country Exclusive'

# SCD Games
scd = (games_2['platform'] == 'SCD') & (games_2['na_sales'] < 1)
games_2.loc[scd,['rating']] = 'No Rating: Country Exclusive'

# Sonic CD was given an E rating
soncd = (games_2['platform'] == 'SCD') & (games_2['na_sales'] > 0)
games_2.loc[soncd,['rating']] = 'E'

# Those were the platforms with the lowest amount of missing data; let's look at a few more
display(missing_platform)

games_2[games_2['platform'] == 'XOne']
games_2[(games_2['platform'] == 'XOne') & (games_2['rating'].isna())]

# All of these Walking Dead games appear to be rated M, they are in the same year and on similar consoles
wd = (games_2['name'].str.contains('The Walking Dead', case = False, na = False))
games_2.loc[wd,['rating']] = 'M'

# The Mad Max games appear to be M rated
mad = (games_2['name'].str.contains('Mad Max', case = False, na = False))
games_2.loc[mad,['rating']] = 'M'

# The thief (2014) games appear to be rated 'M'
thief = (games_2['name'].str.contains('thief ', case = False, na = False)) & (games_2['year_of_release'] == 2014)
games_2.loc[thief,['rating']] = 'M'

# It appears that all the disney infinity games should be rated E10+
di = (games_2['name'].str.contains('disney infinity', case = False, na = False))
games_2.loc[di,['rating']] = 'E10+'

# Rocksmith games can be labeled as T
rs = (games_2['name'].str.contains('Rocksmith 2014', case = False, na = False))
games_2.loc[rs,['rating']] = 'T'

# zoo tycoon is rated E
zoo = (games_2['name'].str.contains('zoo tycoon', case = False, na = False))
games_2.loc[zoo,['rating']] = 'E'

# THe amazing spider man is rated T
spider = (games_2['name'].str.contains('the amazing spider', case = False, na = False))
games_2.loc[spider,['rating']] = 'T'

# State of decay is rated M
decay = (games_2['name'].str.contains('decay', case = False, na = False))
games_2.loc[decay,['rating']] = 'M'

# The farming simulator appears to be rated 'E'
farm = (games_2['name'].str.contains('farming sim', case = False, na = False))
games_2.loc[farm,['rating']] = 'E'

# The transformers rise was rated T except on the 3DS it was rated E10+
formers = (games_2['name'].str.contains('Transformer: Rise', case = False, na = False)) & (games_2['platform'] != '3DS')
games_2.loc[formers,['rating']] = 'T'

rformers = (games_2['name'].str.contains('Transformer: Rise', case = False, na = False)) & (games_2['platform'] == '3DS')
games_2.loc[rformers,['rating']] = 'E10+'

# The rest of the NaN values for the Sherlock Holmes games is M, except for the Wii version which is rated T
sherlock = (games_2['name'].str.contains('Sherlock Holmes', case = False, na = False)) & (games_2['rating'].isna()) & (games_2['platform'] != 'Wii')
games_2.loc[sherlock,['rating']] = 'M'

sherlock1 = (games_2['name'].str.contains('Sherlock Holmes', case = False, na = False)) & (games_2['rating'].isna()) & (games_2['platform'] == 'Wii')
games_2.loc[sherlock1,['rating']] = 'T'

# Attack on Titan is rated M
titan = (games_2['name'].str.contains('attack on titan', case = False, na = False))
games_2.loc[titan,['rating']] = 'M'

# Adventure time is rated E10+
ats = (games_2['name'].str.contains('adventure time', case = False, na = False))
games_2.loc[ats,['rating']] = 'E10+'

# RBI baseball is rated E
rbi = (games_2['name'].str.contains('r.b.i. baseball', case = False, na = False))
games_2.loc[rbi,['rating']] = 'E'

# Ghost busters: The video game for the NaN values is E
gbv = (games_2['name'].str.contains('ghostbusters: The Vid', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[gbv,['rating']] = 'E'

# The other NaN ghostbusters games are rated E10
gb = (games_2['name'].str.contains('ghostbusters', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[gb,['rating']] = 'E10+'

# The NaN values for GOT is M
got = (games_2['name'].str.contains('game of thrones', case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[got,['rating']] = 'M'

# Pac-man is rated E
pac = (games_2['name'].str.contains('pac-man champion', case = False, na = False))
games_2.loc[pac,['rating']] = 'E'

# WRC games are rated E
wrc = (games_2['name'].str.contains('wrc', case = False, na = False))
games_2.loc[wrc,['rating']] = 'E'

# Psycho pass is rated T
psycho = (games_2['name'].str.contains('psycho-pass', case = False, na = False))
games_2.loc[psycho,['rating']] = 'T'

# Hitman (2016) is rated 'M'
hitman = games_2['name'] == 'Hitman (2016)'
games_2.loc[hitman,['rating']] = 'M'

# the Katekyoo games are not rated
kate = (games_2['name'].str.contains('Katekyoo', case = False, na = False))
games_2.loc[kate,['rating']] = 'No Rating: Country Exclusive'

# Rabbids invasion is rated E10+
rabbid = (games_2['name'].str.contains("rabbids invasion", case = False, na = False))
games_2.loc[rabbid,['rating']] = 'E10+'
games_2[(games_2['name'].str.contains("rabbids invasion", case = False, na = False))]
#games_2[(games_2['platform'] == 'XOne') & (games_2['rating'].isna())]

platform
3DO       2
TG16      2
SCD       4
XOne     23
WiiU     26
GC       44
XB       58
PS4      79
PC      104
X360    158
3DS     246
PSV     246
Wii     247
PS3     307
DS      532
PS2     561
PSP     611
PS      611
dtype: int64

# Examine the data
games_2.info()

missing = games_2[games_2['rating'].isnull()]
display(missing)

missing_platform = missing.groupby('platform').size().sort_values()
display(missing_platform)

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              12986 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

platform
WiiU     19
GC       44
XB       58
PS4      60
PC       96
X360    141
3DS     239
PSV     240
Wii     243
PS3     290
DS      520
PS2     557
PSP     607
PS      611
dtype: int64

# We can reasonably assume that games with no na_sales, or eu_sales with very low sales are not rated
ls = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.02)
games_2.loc[ls,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.02)]

# Let's check more low scores
games_2[games_2['rating'].isna() & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.03)].head(60)

# Looking at the first 60 rows, there are no ESRB rated games, we can reasonably assume all titles are not rated
lows = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.03)
games_2.loc[lows,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['rating'] != 'No Rating: Country Exclusive') & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.03)]

games_2[(games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.03)]

# Let's check more low scores
games_2[games_2['rating'].isna() & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.04)].head(60)

# Looking at the first 60 rows, there are no ESRB rated games, we can reasonably assume all titles are not rated
los = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.04)
games_2.loc[los,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['rating'] != 'No Rating: Country Exclusive') & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.04)]

games_2[(games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.04)]

#games_2[(games_2['name'].str.contains("Project Gotham Racing 2", case = False, na = False))]

# Examine the data
games_2.info()


missing = games_2[games_2['rating'].isnull()]

missing_platform = missing.groupby('platform').size().sort_values()
display(missing_platform)

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              13939 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

platform
WiiU     14
PS4      42
GC       44
XB       57
PC       96
X360     98
PSV     100
3DS     191
PS3     204
Wii     216
PSP     343
PS2     377
DS      387
PS      603
dtype: int64

# Let's check more low scores - we are going to assume that anything that made less than 500,000 in total sales and only has jp_sales is exclusive

games_2[games_2['rating'].isna() & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] <= 0.49)]

# less than 500,000 in jp_sales only
lo50 = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.49)
games_2.loc[lo50,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['rating'] != 'No Rating: Country Exclusive') & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.49)]

games_2[(games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) & (games_2['jp_sales'] < 0.49)]

# We are going to assume the rest of the data is country exclusive, there is a limited amount of data that only has JP sales 

games_2[games_2['rating'].isna() & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0)]


je = (games_2['rating'].isna()) & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0) 
games_2.loc[je,['rating']] = 'No Rating: Country Exclusive'

games_2[(games_2['rating'] != 'No Rating: Country Exclusive') & (games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0)]

games_2[(games_2['na_sales'] == 0) & (games_2['eu_sales'] == 0)]

# Most sports games are likely rated E
games_2[(games_2['genre'] == 'Sports') & (games_2['rating'].isna())]

sports = (games_2['genre'] == 'Sports') & (games_2['rating'].isna())
games_2.loc[sports,['rating']] = 'E'

games_2[(games_2['genre'] == 'Sports')]

# Look at what rating fits which genre best
e10 = games_2[games_2['rating'] == 'E10+']
t = games_2[games_2['rating'] == 'T']
m = games_2[games_2['rating'] == 'M']
e = games_2[games_2['rating'] == 'E']

display(e10['genre'].value_counts())
display(t['genre'].value_counts())
display(m['genre'].value_counts())
display(e['genre'].value_counts())

genre
Action          514
Misc            176
Platform        149
Racing          136
Role-Playing    117
Sports          112
Strategy         79
Adventure        77
Shooter          56
Simulation       51
Puzzle           36
Fighting         23
Name: count, dtype: int64

genre
Action          766
Fighting        473
Role-Playing    469
Shooter         390
Misc            256
Racing          213
Sports          204
Simulation      202
Strategy        174
Adventure       130
Platform         68
Puzzle            6
Name: count, dtype: int64

genre
Action          696
Shooter         605
Role-Playing    178
Adventure       138
Fighting         57
Strategy         27
Racing           19
Sports           18
Misc             17
Platform          5
Simulation        5
Name: count, dtype: int64

genre
Sports          1677
Racing           857
Misc             571
Action           534
Platform         487
Puzzle           485
Simulation       365
Adventure        188
Role-Playing     170
Strategy          99
Shooter           64
Fighting          18
Name: count, dtype: int64

# Most fighting games are T rated
games_2[(games_2['genre'] == 'Fighting') & (games_2['rating'].isna())].head(60)

# Right away I see mortal kombat which typically carries an M rating and Pac-Man which typically carries an E rating

mortalk = (games_2['name'].str.contains("mortal kombat", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[mortalk,['rating']] = 'M'

mortalk1 = (games_2['name'].str.contains("mortal kombat", case = False, na = False)) & (games_2['platform'] == 'N64')
games_2.loc[mortalk1,['rating']] = 'M'

pacg = (games_2['name'].str.contains("pac-man & gal", case = False, na = False))
games_2.loc[pacg,['rating']] = 'E10+'

pacna = (games_2['name'].str.contains("pac-man", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[pacna,['rating']] = 'E'

games_2[(games_2['name'].str.contains("pac-man", case = False, na = False))]

# Look at fighting games again since most are T rated
games_2[(games_2['genre'] == 'Fighting') & (games_2['rating'].isna())]

# These title names align with a T rating
fight = (games_2['genre'] == 'Fighting') & (games_2['rating'].isna())
games_2.loc[fight,['rating']] = 'T'

games_2[(games_2['genre'] == 'Fighting') & (games_2['rating'].isna())]
#games_2[(games_2['name'].str.contains("pac-man", case = False, na = False))]

# Platform genre most aligns with E and E10+, we can safely assume platform games before 2005 received an E rating
games_2[(games_2['genre'] == 'Platform') & (games_2['rating'].isna()) & (games_2['year_of_release'] < 2005)]
plate = (games_2['genre'] == 'Platform') & (games_2['rating'].isna()) & (games_2['year_of_release'] < 2005)
games_2.loc[plate,['rating']] = 'E'

# Most DS games probably received an E rating
games_2[(games_2['genre'] == 'Platform') & (games_2['rating'].isna()) & (games_2['platform'].isin(['DS','3DS']))]
dsplat = (games_2['genre'] == 'Platform') & (games_2['rating'].isna()) & (games_2['platform'].isin(['DS','3DS']))
games_2.loc[dsplat,['rating']] = 'E'

# The wii games have both E and E10 ratings
wii = (games_2['genre'] == 'Platform') & (games_2['rating'].isna()) & (games_2['platform'] == 'Wii') & (games_2['total_sales'] < 0.6) & (games_2['total_sales'] > 0.25)
games_2.loc[wii,['rating']] = 'E10+'

wii1 = (games_2['genre'] == 'Platform') & (games_2['rating'].isna()) & (games_2['platform'] == 'Wii')
games_2.loc[wii1,['rating']] = 'E'


# The scooby doo games are rated E
games_2[(games_2['name'].str.contains("scooby", case = False, na = False)) & (games_2['genre'].isin(['Platform','Adventure']))]
scooby = (games_2['name'].str.contains("scooby", case = False, na = False)) & (games_2['genre'].isin(['Platform','Adventure']))
games_2.loc[scooby,['rating']] = 'E'

# The rest of the scooby doo's are rated E10
scooby1 = (games_2['name'].str.contains("scooby", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[scooby1,['rating']] = 'E10+'

# 2 games are rated T
prin = games_2['name'] == 'Prinny 2: Dawn of Operation Panties, Dood!'
games_2.loc[prin,['rating']] = 'T'

smb = games_2['name'] == 'Super Meat Boy: Ultra Edition!'	
games_2.loc[smb,['rating']] = 'T'

# All other games should be rated E10
plat = (games_2['genre'] == 'Platform') & (games_2['rating'].isna())
games_2.loc[plat,['rating']] = 'E10+'


games_2[(games_2['genre'] == 'Platform') & (games_2['rating'].isna())]

# Let's assume any game that has 0 na_sales is not rated
games_2[(games_2['rating'].isna()) & (games_2['na_sales'] == 0)]

nona = (games_2['rating'].isna()) & (games_2['na_sales'] == 0)
games_2.loc[nona,['rating']] = 'No Rating: Country Exclusive'

games_2[games_2['rating'].isna() & (games_2['na_sales'] == 0)]

# Remaining DS shooter games are rated T and E10
shooterds = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['genre'] == 'Shooter') & (games_2['year_of_release'] == 2006)
games_2.loc[shooterds, ['rating']] = 'E10+'

shoods = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['genre'] == 'Shooter')
games_2.loc[shoods,['rating']] = 'T'

# Look at DS adventure games
phoenix = (games_2['name'].str.contains("phoenix wright", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[phoenix,['rating']] = 'T'

pho = games_2['name'] == 'Phoenix Wright: Revived Turnabout'
games_2.loc[pho,['rating']] = 'M'

games_2[(games_2['name'].str.contains("phoenix wright", case = False, na = False))]


# We need more information

# Look at what rating fits which genre best

e10 = games_2[(games_2['rating'] == 'E10+') & (games_2['platform'] == 'DS')]
t = games_2[(games_2['rating'] == 'T') & (games_2['platform'] == 'DS')]
m = games_2[(games_2['rating'] == 'M') & (games_2['platform'] == 'DS')]
e = games_2[(games_2['rating'] == 'E') & (games_2['platform'] == 'DS')]

display(e10[['genre','year_of_release']].value_counts().head(25))
display(t[['genre','year_of_release']].value_counts().head(25))
display(m[['genre','year_of_release']].value_counts().head(25))
display(e[['genre','year_of_release']].value_counts().head(25))

genre         year_of_release
Action        2010.0             18
Role-Playing  2008.0             15
Action        2009.0             14
              2008.0             14
              2007.0             13
Role-Playing  2007.0             10
              2009.0             10
Action        2011.0              9
Role-Playing  2006.0              8
              2010.0              8
Puzzle        2009.0              7
Misc          2008.0              7
Strategy      2007.0              6
Action        2006.0              6
              2005.0              5
Strategy      2008.0              5
Adventure     2011.0              5
              2008.0              5
              2010.0              5
Misc          2010.0              5
              2007.0              4
Action        2012.0              4
Simulation    2008.0              4
Puzzle        2007.0              4
Platform      2007.0              4
Name: count, dtype: int64

genre         year_of_release
Role-Playing  2008.0             10
Action        2008.0              8
Adventure     2009.0              7
              2008.0              6
Role-Playing  2007.0              5
Adventure     2007.0              5
Misc          2007.0              4
Sports        2010.0              4
Adventure     2010.0              4
Action        2006.0              4
Role-Playing  2009.0              3
Misc          2005.0              3
Action        2009.0              3
              2010.0              3
Shooter       2007.0              3
Fighting      2010.0              2
              2006.0              2
Action        2011.0              2
Fighting      2009.0              2
Action        2005.0              2
Adventure     2005.0              2
              2006.0              2
Shooter       2008.0              2
              2010.0              2
Fighting      2008.0              2
Name: count, dtype: int64

genre         year_of_release
Shooter       2007.0             3
              2009.0             2
              2010.0             2
Action        2006.0             1
Adventure     2009.0             1
              2008.0             1
Action        2009.0             1
Fighting      2007.0             1
Role-Playing  2009.0             1
Misc          2008.0             1
Shooter       2008.0             1
              2011.0             1
Name: count, dtype: int64

genre       year_of_release
Simulation  2009.0             57
            2008.0             46
Puzzle      2009.0             44
            2007.0             40
Misc        2008.0             38
Puzzle      2008.0             34
Sports      2008.0             33
Simulation  2007.0             32
Misc        2009.0             31
            2010.0             30
Puzzle      2010.0             29
Simulation  2010.0             28
Adventure   2008.0             23
Action      2009.0             23
Misc        2007.0             23
Puzzle      2011.0             22
Action      2007.0             19
            2006.0             18
Sports      2007.0             17
Adventure   2009.0             17
Action      2008.0             17
Sports      2009.0             16
Puzzle      2006.0             16
Racing      2008.0             14
Puzzle      2005.0             14
Name: count, dtype: int64

# Use the above data to input ratings
games_2[(games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2008) & (games_2['genre'].isin(['Role-Playing','Action']))]

# jack*** is rated T
jack = games_2['name'] == 'Jackass the Game DS'
games_2.loc[jack,['rating']] = 'T'

# Phoenix star is E10
ps = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2008) & (games_2['genre'].isin(['Role-Playing','Action'])) & (games_2['total_sales'] == 0.37)
games_2.loc[ps,['rating']] = 'E10+'

# The rest are rated E
eg = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2008) & (games_2['genre'].isin(['Role-Playing','Action']))
games_2.loc[eg,['rating']] = 'E'

# Looking at 2006 action games
act06 = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['total_sales'] < 0.03) & (games_2['year_of_release'] == 2006) & (games_2['genre'].isin(['Action']))
games_2.loc[act06,['rating']] = 'E10+'

# The rest are rated E
e06 = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2006) & (games_2['genre'].isin(['Action']))
games_2.loc[e06,['rating']] = 'E'

# Some 09 games are E10
g10 = (games_2['rating'].isna()) & (games_2['eu_sales'] > 0.01) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Action']))
games_2.loc[g10,['rating']] = 'E10+'

g09 = (games_2['rating'].isna()) & (games_2['na_sales'] == 0.09) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Action']))
games_2.loc[g09,['rating']] = 'E10+'


# The rest are rated E
gam = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Action']))
games_2.loc[gam,['rating']] = 'E'

# It's unlikely there are any more M rated games

# Let's look at adventure 07 - 09: 07 are all E, 2008 - T - Dragon Ball: Origins, the rest are E, 
# 2009 - 999: Nine Hours, Nine Persons, Nine Doors is rated M, 
# 2009 - CSI: Deadly Intent - The Hidden Case is rated T,
# 2009 - Broken Sword: Shadows of the Templars - The Di... is rated T,
# 2009 - Again is rated T
dbo = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['jp_sales'] > 0) & (games_2['year_of_release'] == 2008) & (games_2['genre'].isin(['Adventure']))
games_2.loc[dbo,['rating']] = 'T'

ho = (games_2['rating'].isna()) & (games_2['total_sales'] > 0.4) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Adventure']))
games_2.loc[ho,['rating']] = 'E10+'

pet = (games_2['rating'].isna()) & (games_2['other_sales'] == 0.01) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Adventure']))
games_2.loc[pet,['rating']] = 'E'

sarah = (games_2['rating'].isna()) & (games_2['total_sales'] == 0.01) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Adventure']))
games_2.loc[sarah,['rating']] = 'E'

t9 = (games_2['rating'].isna()) & (games_2['total_sales'] < 0.36) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Adventure']))
games_2.loc[t9,['rating']] = 'T'

m9 = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Adventure']))
games_2.loc[m9,['rating']] = 'M'

e78 = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2009)  & (games_2['year_of_release'] > 2006) & (games_2['genre'].isin(['Adventure']))
games_2.loc[e78,['rating']] = 'E'


# Look at R-P games in 07 - they are all different ratings
dig = (games_2['rating'].isna()) & (games_2['total_sales'] == 0.31) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2007) & (games_2['genre'].isin(['Role-Playing']))
games_2.loc[dig,['rating']] = 'E'

ron = (games_2['rating'].isna()) & (games_2['total_sales'] == 0.16) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2007) & (games_2['genre'].isin(['Role-Playing']))
games_2.loc[ron,['rating']] = 'E10+'

orc = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2007) & (games_2['genre'].isin(['Role-Playing']))
games_2.loc[orc,['rating']] = 'T'


# Look at Adventure 10
# CSI: Unsolved! = T
csi = (games_2['name'].str.contains("CSI", case = False, na = False)) & (games_2['platform'] == 'DS')
games_2.loc[csi,['rating']] = 'T'

csi1 = (games_2['name'].str.contains("CSI", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[csi1,['rating']] = 'M'

# The gromiti Wii games is E10 and the gormiti DS game is E
gorw = (games_2['name'].str.contains("gormi", case = False, na = False)) & (games_2['platform'] == 'Wii')
gord = (games_2['name'].str.contains("gormi", case = False, na = False)) & (games_2['platform'] == 'DS')
games_2.loc[gorw,['rating']] = 'E10+'
games_2.loc[gord,['rating']] = 'E'

# The rest are different ratings
club = (games_2['rating'].isna()) & (games_2['total_sales'] > 0.6) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2010) & (games_2['genre'].isin(['Adventure']))
games_2.loc[club,['rating']] = 'E'

witches = (games_2['rating'].isna()) & (games_2['total_sales'] > 0.07) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2010) & (games_2['genre'].isin(['Adventure']))
games_2.loc[witches,['rating']] = 'E10+'

jek = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2010) & (games_2['genre'].isin(['Adventure']))
games_2.loc[jek,['rating']] = 'T'


# Look at Role-Playing. in 09
# All might and magic clash games are E10
# Legacy is rated T
clash = (games_2['rating'].isna()) & (games_2['total_sales'] > 0.07) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Role-Playing']))
games_2.loc[clash,['rating']] = 'E10+'

leg = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2009) & (games_2['genre'].isin(['Role-Playing']))
games_2.loc[leg,['rating']] = 'T'


# Look at Action in 2010
# Toy story 3 is E in everything, but Wii, PC, PS3, and X360 it's E10
ts3 = (games_2['name'].str.contains("toy story 3", case = False, na = False)) & (games_2['platform'].isin(['DS','PSP']))
games_2.loc[ts3,['rating']] = 'E'

tsna =  (games_2['name'].str.contains("toy story 3", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[tsna,['rating']] = 'E10+'

# Tangled is E across platforms
tang = (games_2['name'].str.contains("tangled", case = False, na = False))
games_2.loc[tang,['rating']] = 'E'

# Goldeneye 007 is T across platforms
gey = (games_2['name'].str.contains("goldeneye 007", case = False, na = False))
games_2.loc[gey,['rating']] = 'T'

# Bakugan: Battle games are E across platforms
bb = (games_2['name'].str.contains("bakugan: battle", case = False, na = False))
games_2.loc[bb,['rating']] = 'E'


# transformers: war for cybertron games are E10 and T
# T - PC, PS3, x360
cyb = (games_2['name'].str.contains("transformers: war for cybertron", case = False, na = False)) & (games_2['platform'] == 'DS')
games_2.loc[cyb,['rating']] = 'E10+'

cybna = (games_2['name'].str.contains("transformers: war for cybertron", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[cybna,['rating']] = 'T'

#The rest are E except kung zhu
kz = (games_2['rating'].isna()) & (games_2['total_sales'] > 0.11) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2010) & (games_2['genre'].isin(['Action']))
games_2.loc[kz,['rating']] = 'E10+'

cds = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] == 2010) & (games_2['genre'].isin(['Action']))
games_2.loc[cds,['rating']] = 'E'


# The rest of the games are likely E or E10+
# Look at games before 2005 
# The utbz is rated E on DS and GBA and rated T elsewhere
uz = (games_2['name'].str.contains("the urbz", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[uz,['rating']] = 'E'

# Sprung is rated T
spr = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2005)
games_2.loc[spr,['rating']] = 'T'


# Look at games from 2005
# Nintendogs is rated E across platforms
nd = (games_2['name'].str.contains("nintendogs", case = False, na = False))
games_2.loc[nd,['rating']] = 'E'

# Harvest Moon games appear to be E across platforms
hm = (games_2['name'].str.contains("harvest moon", case = False, na = False))
games_2.loc[hm,['rating']] = 'E'

# Viewtiful Joe: Double Trouble is rated T
# Shamu games are rated E across platforms
# Tao adventure rated E10
# The rest are rated E
view = (games_2['name'].str.contains("Viewtiful", case = False, na = False))
games_2.loc[view,['rating']] = 'T'

tao = (games_2['name'].str.contains("tao adventure", case = False, na = False))
games_2.loc[tao,['rating']] = 'E10+'

sham = (games_2['name'].str.contains("shamu", case = False, na = False))
games_2.loc[sham,['rating']] = 'E'

re = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2006)
games_2.loc[re,['rating']] = 'E'


# Nicktoons rated E across platforms
nt = (games_2['name'].str.contains("nicktoons", case = False, na = False))
games_2.loc[nt,['rating']] = 'E'

# Trying to rate all transformers games
beast = (games_2['name'].str.contains("beast wars", case = False, na = False))
games_2.loc[beast,['rating']] = 'E'

dom = (games_2['name'].str.contains("transformers: dark of the moon", case = False, na = False)) & ~(games_2['platform'].isin(['X360','PS3']))
games_2.loc[dom,['rating']] = 'E10+'

rof = (games_2['name'].str.contains("revenge of the fallen", case = False, na = False)) & (games_2['platform'] == 'PSP')
games_2.loc[rof,['rating']] = 'E10+'

rof1 = (games_2['name'].str.contains("revenge of the fallen", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[rof1,['rating']] = 'T'

tg =  (games_2['name'].str.contains("transformers: the game", case = False, na = False)) & (games_2['platform'] == 'PSP')
games_2.loc[tg,['rating']] = 'E10+'

tg1 = (games_2['name'].str.contains("transformers: the game", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[tg1,['rating']] = 'T'

tp = (games_2['name'].str.contains("transformers: prime", case = False, na = False))
games_2.loc[tp,['rating']] = 'E10+'

tna = (games_2['name'].str.contains("transformers", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[tna,['rating']] = 'E10+'


# paws and claws rated E across platforms
# Avatar: The Last Airbender - The Burning Earth E10 on PS2, Wii, X360
# Panzer Tactics rated E10+
# The rest are rated E
panc = (games_2['name'].str.contains("paws & claws", case = False, na = False))
games_2.loc[panc,['rating']] = 'E'

atab = (games_2['name'].str.contains("avatar: The last Airbender - The Burning", case = False, na = False)) & (games_2['platform'] != 'DS')
games_2.loc[atab,['rating']] = 'E10+'

pt = (games_2['name'].str.contains("panzer tactics", case = False, na = False))
games_2.loc[pt,['rating']] = 'E10+'

erated = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2008)
games_2.loc[erated,['rating']] = 'E'


# Hell's Kitchen's games are rated T
hk = (games_2['name'].str.contains("Hell's Kitchen", case = False, na = False))
games_2.loc[hk,['rating']] = 'T'


# Fantasty Aquarium rated E across platforms
fa = (games_2['name'].str.contains("Aquarium", case = False, na = False))
games_2.loc[fa,['rating']] = 'E'


# The rest are rated E
e08 = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2009)
games_2.loc[e08,['rating']] = 'E'


# The Dreamer Series is rated E
dream = (games_2['name'].str.contains("Dreamer Series", case = False, na = False))
games_2.loc[dream,['rating']] = 'E'

# Jambo is rated E
jam = (games_2['name'].str.contains("jambo!", case = False, na = False))
games_2.loc[jam,['rating']] = 'E'

# Emergency is rated E10
em = (games_2['name'].str.contains("emergency!", case = False, na = False))
games_2.loc[em,['rating']] = 'E10+'

# Yu-Gi-Oh! 5D's World Championship 2010 is rated E10+
yu = (games_2['name'].str.contains("Yu-Gi-Oh! 5D's World Championship 2010", case = False, na = False))
games_2.loc[yu,['rating']] = 'E10+'

# Kung Fu Panda 2 on the DS is the only game rated E, the others are rated E10+
kfp = (games_2['name'].str.contains("Kung Fu Panda 2", case = False, na = False)) & (games_2['platform'] == 'DS')
games_2.loc[kfp,['rating']] = 'E'

kfp1 = (games_2['name'].str.contains("Kung Fu Panda", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[kfp1,['rating']] = 'E10+'


# All zhu zhu games rated E
zhu = (games_2['name'].str.contains("zhuzhu", case = False, na = False))
games_2.loc[zhu,['rating']] = 'E'

# Spongebob games are rated E, but E10 in plankton's robotic revenge
sbsp = (games_2['name'].str.contains("Spongebob", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[sbsp,['rating']] = 'E'

#The penguins of madagascar are rated E across platforms
pomg = (games_2['name'].str.contains("penguins of mada", case = False, na = False))
games_2.loc[pomg,['rating']] = 'E'


# The rest of the games are rated E
dse = (games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2017)
games_2.loc[dse,['rating']] = 'E'

games_2.info()


e10 = games_2[games_2['rating'] == 'E10+']
t = games_2[games_2['rating'] == 'T']
m = games_2[games_2['rating'] == 'M']
e = games_2[games_2['rating'] == 'E']

display(e10[['genre']].value_counts().head(25))
display(e10[['platform']].value_counts().head(25))
display(t[['platform']].value_counts().head(25))
display(t[['platform']].value_counts().head(25))
display(m[['platform']].value_counts().head(25))
display(m[['platform']].value_counts().head(25))
display(e[['platform']].value_counts().head(25))
display(e[['platform']].value_counts().head(25))

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              15995 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

genre       
Action          545
Misc            177
Platform        164
Racing          136
Role-Playing    121
Sports          112
Strategy         81
Adventure        81
Shooter          59
Simulation       52
Puzzle           36
Fighting         23
Name: count, dtype: int64

platform
DS          292
Wii         258
X360        191
PS3         164
PS2         134
PSP         113
3DS          92
PC           85
WiiU         52
PS4          50
XOne         40
PSV          34
XB           32
GC           32
GBA           7
SNES          6
PS            3
2600          1
GEN           1
Name: count, dtype: int64

platform
PS2         627
PS3         371
X360        361
PC          316
XB          309
Wii         232
PSP         217
GC          183
PS          183
DS          140
PS4         108
PSV          87
GBA          87
N64          58
3DS          57
XOne         51
SAT          36
DC           21
WiiU         19
SNES          4
2600          1
GEN           1
Name: count, dtype: int64

platform
PS2         627
PS3         371
X360        361
PC          316
XB          309
Wii         232
PSP         217
GC          183
PS          183
DS          140
PS4         108
PSV          87
GBA          87
N64          58
3DS          57
XOne         51
SAT          36
DC           21
WiiU         19
SNES          4
2600          1
GEN           1
Name: count, dtype: int64

platform
X360        312
PS3         286
PC          274
PS2         227
XB          165
PS4         114
XOne        102
PSP          55
PS           41
PSV          41
GC           40
Wii          37
N64          23
WiiU         18
DS           17
3DS          13
DC            4
SAT           2
GEN           2
GBA           1
SNES          1
Name: count, dtype: int64

platform
X360        312
PS3         286
PC          274
PS2         227
XB          165
PS4         114
XOne        102
PSP          55
PS           41
PSV          41
GC           40
Wii          37
N64          23
WiiU         18
DS           17
3DS          13
DC            4
SAT           2
GEN           2
GBA           1
SNES          1
Name: count, dtype: int64

platform
DS          1103
GBA          684
PS2          635
Wii          606
PS           476
X360         292
XB           280
GC           266
PS3          254
PSP          223
N64          208
PC           183
3DS          126
GB            98
PS4           62
XOne          54
SNES          43
WiiU          40
PSV           29
SAT           28
NES           15
DC            11
GEN            7
2600           3
3DO            1
Name: count, dtype: int64

platform
DS          1103
GBA          684
PS2          635
Wii          606
PS           476
X360         292
XB           280
GC           266
PS3          254
PSP          223
N64          208
PC           183
3DS          126
GB            98
PS4           62
XOne          54
SNES          43
WiiU          40
PSV           29
SAT           28
NES           15
DC            11
GEN            7
2600           3
3DO            1
Name: count, dtype: int64

missing = games_2[games_2['rating'].isnull()]

missing_platform = missing.groupby('platform').size().sort_values()
display(missing_platform)

platform
WiiU      8
PS4      10
PSV      14
GC       14
PC       27
3DS      28
PSP      33
XB       36
PS3      39
X360     40
Wii      56
PS2      77
PS      334
dtype: int64

# Let's look at the missing WiiU games
games_2[(games_2['platform'] == 'WiiU') & (games_2['rating'].isna())]


# Shin Megami games are either T or M
# Persona 2 on the PSP is T rated
pers = (games_2['name'].str.contains("persona 2: innocent", case = False, na = False))
games_2.loc[pers,['rating']] = 'T'

dso = (games_2['name'].str.contains("devil survivor", case = False, na = False))
games_2.loc[dso,['rating']] = 'T'

# I don't think the Fire Emblem game came out until after this data; this will be marked as country exclusive for now
fe = games_2['name'] == 'Shin Megami Tensei x Fire Emblem'
games_2.loc[fe,['rating']] = 'No Rating: Country Exclusive'

# The missing shin games are rated M
shin = (games_2['name'].str.contains("shin megami", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[shin,['rating']] = 'M'

# The PS2 raidou game is rated M
raid = (games_2['name'].str.contains("raidou", case = False, na = False))
games_2.loc[raid,['rating']] = 'M'

# Persona 3 was rated M
p3 = (games_2['name'].str.contains("persona 3", case = False, na = False))
games_2.loc[p3,['rating']] = 'M'

# Wipeout 3 is rated E10 on all consoles except PS
wo = (games_2['name'].str.contains("wipeout 3", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[wo,['rating']] = 'E10+'

woo = (games_2['name'].str.contains("wipeout", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[woo,['rating']] = 'E'

# The james bond games are rated T
jb = (games_2['name'].str.contains("james bond 007", case = False, na = False))
games_2.loc[jb,['rating']] = 'T'


# The voice is rated E10
voice = (games_2['name'].str.contains("The Voice", case = False, na = False))
games_2.loc[voice,['rating']] = 'E10+'

# The croods is rated E
crood = (games_2['name'].str.contains("The Croods", case = False, na = False))
games_2.loc[crood,['rating']] = 'E'

#Disney Planes games are rated E
dp = (games_2['name'].str.contains("Disney Planes", case = False, na = False))
games_2.loc[dp,['rating']] = 'E'

# game and wario is rated E
gw = (games_2['name'].str.contains("game & wario", case = False, na = False))
games_2.loc[gw,['rating']] = 'E'

# Tank! is rated E10
ta = (games_2['name'].str.contains("Tank!", case = False, na = False))
games_2.loc[ta,['rating']] = 'E10+'

# Look at missing PS4 games
games_2[(games_2['platform'] == 'PS4') & (games_2['rating'].isna())]

# MLB 16 is rated E
mlb = (games_2['name'].str.contains("MLB 16", case = False, na = False))
games_2.loc[mlb,['rating']] = 'E'

# Dragon Quest VII is rated E10+
dq = (games_2['name'].str.contains("Dragon Quest VII:", case = False, na = False))
games_2.loc[dq,['rating']] = 'E10+'

# The missing dragon quest heroes game is rated T
dqq = (games_2['name'].str.contains("Dragon Quest Heroes", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[dqq,['rating']] = 'T'

# The dragon quest builders game is rated E10
dqb = (games_2['name'].str.contains("Dragon Quest Builders", case = False, na = False))
games_2.loc[dqb,['rating']] = 'E10+'

# Star Ocean is rated T
so = (games_2['name'].str.contains("Star Ocean", case = False, na = False))
games_2.loc[so,['rating']] = 'T'

# Godzilla is rated T
gz = (games_2['name'].str.contains("Godzilla ", case = False, na = False)) & (games_2['platform'].isin(['PS3','PS4']))
games_2.loc[gz,['rating']] = 'T'

# Akiba's Trip is rated M
at = (games_2['name'].str.contains("Akiba's Trip", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[at,['rating']] = 'M'

# THe missing 3 kingdoms game is rated E10
rok = (games_2['name'].str.contains("Romance of the Three Kingdoms", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[rok,['rating']] = 'E10+'

# The sphere nobun games are rated T
spn = (games_2['name'].str.contains("Nobunaga's Ambition: sphere of", case = False, na = False))
games_2.loc[spn,['rating']] = 'T'

# The warhammer dawn of war games are rated M
dow = (games_2['name'].str.contains("warhammer 40,000: dawn of war", case = False, na = False))
games_2.loc[dow,['rating']] = 'M'

# Warhammer: shadow is rated E
ws = (games_2['name'].str.contains("warhammer: shadow", case = False, na = False))
games_2.loc[ws,['rating']] = 'E'


# Warhammer: dark omen is rated T
wd = (games_2['name'].str.contains("warhammer: dark", case = False, na = False))
games_2.loc[wd,['rating']] = 'T'

# Warhammer: The end is rated M
we = (games_2['name'].str.contains("warhammer: the end", case = False, na = False))
games_2.loc[we,['rating']] = 'M'

# Loading Human is rated T
lh = (games_2['name'].str.contains("loading human", case = False, na = False))
games_2.loc[lh,['rating']] = 'T'



games_2[(games_2['platform'] == 'PS4') & (games_2['rating'].isna())]

# look at PSV games
games_2[(games_2['platform'] == 'PSV') & (games_2['rating'].isna())]

# The Hyperdimension NaN values are rated T
hyper = (games_2['name'].str.contains("Hyperdimension", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[hyper,['rating']] = 'T'

# The missing shiren game is rated E10
shiren = (games_2['name'].str.contains("Shiren", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[shiren,['rating']] = 'E10+'

# Shinobido rated M
# yom is rated M
# Dungeon Travelers is rated M
syd = (games_2['platform'] == 'PSV') & (games_2['total_sales'] > 0.1) & (games_2['total_sales'] < 0.14) & (games_2['rating'].isna())
games_2.loc[syd,['rating']] = 'M'

# Makai Shin is not rated, country exclusive
ms = (games_2['platform'] == 'PSV') & (games_2['jp_sales'] == 0.06) & (games_2['rating'].isna())
games_2.loc[ms,['rating']] = 'No Rating: Country Exclusive'

# Criminal girls is rated M
cg = (games_2['platform'] == 'PSV') & (games_2['name'] == 'Criminal Girls 2') & (games_2['rating'].isna())
games_2.loc[cg,['rating']] = 'M'


# Tales of Hearts rated T
# Code:Realize is rated T
# MegaTagmension is rated T
# MeiQ is rated T
tcmm = (games_2['platform'] == 'PSV') & (games_2['rating'].isna())
games_2.loc[tcmm,['rating']] = 'T'

games_2[(games_2['name'].str.contains("MeiQ", case = False, na = False))] 

games_2[(games_2['platform'] == 'PSV') & (games_2['rating'].isna())]



#games_2[(games_2['rating'].isna()) & (games_2['platform'].isin(['DS'])) & (games_2['year_of_release'] < 2017)]

#games_2[(games_2['genre'] == 'Platform') & (games_2['rating'].isna())]
#games_2[(games_2['name'].str.contains("pac-man", case = False, na = False))]

missing = games_2[games_2['rating'].isnull()]

missing_platform = missing.groupby('platform').size().sort_values()
display(missing_platform)

platform
GC       14
3DS      22
PC       26
PSP      32
PS3      35
XB       36
X360     37
Wii      54
PS2      77
PS      330
dtype: int64

e10 = games_2[games_2['rating'] == 'E10+']
t = games_2[games_2['rating'] == 'T']
m = games_2[games_2['rating'] == 'M']
e = games_2[games_2['rating'] == 'E']

display(missing[['genre']].value_counts().head(25))
display(missing[['platform']].value_counts().head(25))

display(e10[['genre']].value_counts().head(25))
display(e10[['platform']].value_counts().head(25))
display(t[['genre']].value_counts().head(25))
display(t[['platform']].value_counts().head(25))
display(m[['genre']].value_counts().head(25))
display(m[['platform']].value_counts().head(25))
display(e[['genre']].value_counts().head(25))
display(e[['platform']].value_counts().head(25))

genre       
Action          168
Misc            158
Shooter          97
Role-Playing     76
Strategy         68
Adventure        55
Simulation       41
Name: count, dtype: int64

platform
PS          330
PS2          77
Wii          54
X360         37
XB           36
PS3          35
PSP          32
PC           26
3DS          22
GC           14
Name: count, dtype: int64

genre       
Action          555
Misc            177
Platform        164
Racing          136
Role-Playing    126
Sports          112
Strategy         81
Adventure        81
Shooter          59
Simulation       52
Puzzle           36
Fighting         23
Name: count, dtype: int64

platform
DS          292
Wii         259
X360        193
PS3         166
PS2         134
PSP         113
3DS          94
PC           85
WiiU         55
PS4          52
XOne         40
PSV          36
XB           32
GC           32
GBA           7
SNES          6
PS            4
2600          1
GEN           1
Name: count, dtype: int64

genre       
Action          778
Fighting        561
Role-Playing    479
Shooter         402
Misc            260
Racing          213
Sports          204
Simulation      204
Strategy        176
Adventure       141
Platform         70
Puzzle            6
Name: count, dtype: int64

platform
PS2         627
PS3         375
X360        362
PC          316
XB          309
Wii         232
PSP         218
PS          185
GC          183
DS          140
PS4         113
PSV          95
GBA          87
N64          58
3DS          58
XOne         51
SAT          36
DC           21
WiiU         20
SNES          5
2600          1
GB            1
GEN           1
Name: count, dtype: int64

genre       
Action          701
Shooter         605
Role-Playing    185
Adventure       142
Fighting         63
Strategy         29
Racing           19
Sports           18
Misc             18
Platform          5
Simulation        5
Name: count, dtype: int64

platform
X360        312
PS3         287
PC          276
PS2         230
XB          165
PS4         116
XOne        102
PSP          55
PSV          46
PS           41
GC           40
Wii          37
N64          23
WiiU         18
DS           17
3DS          15
DC            4
SAT           2
GEN           2
GBA           1
SNES          1
Name: count, dtype: int64

genre       
Sports          1677
Racing           857
Misc             582
Action           580
Platform         579
Puzzle           485
Simulation       408
Adventure        208
Role-Playing     172
Strategy         105
Shooter           64
Fighting          21
Name: count, dtype: int64

platform
DS          1104
GBA          684
PS2          635
Wii          608
PS           477
X360         292
XB           280
GC           266
PS3          255
PSP          223
N64          208
PC           183
3DS          128
GB            97
PS4           63
XOne          54
SNES          43
WiiU          43
PSV           29
SAT           28
NES           15
DC            11
GEN            7
2600           3
3DO            1
Name: count, dtype: int64

# Look at the missing shooter category 

# Syphon Filter 2 is rated M
sf2 = (games_2['name'].str.contains("Syphon Filter 2", case = False, na = False))
games_2.loc[sf2,['rating']] = 'M'


# Medal of Honor is rated T
moh = (games_2['name'].str.contains("Medal of Honor: Euro", case = False, na = False))
games_2.loc[moh,['rating']] = 'T'


# Die Hard Trilogy is rated M
dht = (games_2['name'].str.contains("Die Hard Trilogy", case = False, na = False))
games_2.loc[dht,['rating']] = 'M'


# Duke Nukem: Time to Kill is rated M
dnt = (games_2['name'].str.contains("Duke Nukem: Time to Kill", case = False, na = False))
games_2.loc[dnt,['rating']] = 'M'


# The asteroids games are rated E
ast = (games_2['name'].str.contains("Asteroids", case = False, na = False))
games_2.loc[ast,['rating']] = 'E'


# Destroy All Humans! games are rated T
dah = (games_2['name'].str.contains("Destroy All Humans!", case = False, na = False))
games_2.loc[dah,['rating']] = 'T'


# Kane & Lynch: Dead Men are rated M
kl = (games_2['name'].str.contains("Kane & Lynch: Dead Men", case = False, na = False))
games_2.loc[kl,['rating']] = 'M'


# Ratchet & Clank: Going Commando is rated T
rcc = (games_2['name'].str.contains("Ratchet & Clank: Going Commando", case = False, na = False))
games_2.loc[rcc,['rating']] = 'T'


# Ratchet & Clank: Full Frontal Assault	is rated E10
rcf = (games_2['name'].str.contains("Ratchet & Clank: Full Frontal Assault", case = False, na = False))
games_2.loc[rcf,['rating']] = 'E10+'


# Ratchet & Clank: Into the Nexus is rated E10
rci = (games_2['name'].str.contains("Ratchet & Clank: Into the Nexus", case = False, na = False))
games_2.loc[rci,['rating']] = 'E10+'

# Centipede is rated E
cp = (games_2['name'].str.contains("Centipede", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[cp,['rating']] = 'E'


# Duke Nukem: Total Meltdown is rated M
dnt = (games_2['name'].str.contains("duke nukem", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[dnt,['rating']] = 'M'


# Kane & Lynch 2: Dog Days is rated M
kl2 = (games_2['name'].str.contains("Kane & Lynch 2: Dog Days", case = False, na = False))
games_2.loc[kl2,['rating']] = 'M'


# Omega Boost is rated E
ob = (games_2['name'].str.contains("Omega Boost", case = False, na = False))
games_2.loc[ob,['rating']] = 'E'


# Alien Trilogy is rated 'M'
at = (games_2['name'].str.contains("Alien Trilogy", case = False, na = False))
games_2.loc[at,['rating']] = 'M'


# Missile Command is rated E
mc = (games_2['name'].str.contains("Missile Command", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[mc,['rating']] = 'E'


# Independence Day is rated E
id = (games_2['name'].str.contains("Independence Day", case = False, na = False))
games_2.loc[id,['rating']] = 'E'


# Point Blank on the DS is E10
pbds = (games_2['name'].str.contains("Point Blank", case = False, na = False)) & (games_2['platform'] == 'DS')
games_2.loc[pbds,['rating']] = 'E10+'


# Einhänder is rated E
ein = (games_2['name'].str.contains("Einhänder", case = False, na = False))
games_2.loc[ein,['rating']] = 'E'


# Final Doom is rated M
fd = (games_2['name'].str.contains("Final Doom", case = False, na = False))
games_2.loc[fd,['rating']] = 'M'


# Blaster Master: Blasting Again is rated E
bm = (games_2['name'].str.contains("Blaster Master: Blasting Again", case = False, na = False))
games_2.loc[bm,['rating']] = 'E'


# Project Overkill is rated M
po = (games_2['name'].str.contains("Project Overkill", case = False, na = False))
games_2.loc[po,['rating']] = 'M'

# Forsaken is rated M
fs = games_2['name'] == 'Forsaken'
games_2.loc[fs,['rating']] = 'M'


# The Raiden Project is rated E
rp = (games_2['name'].str.contains("The Raiden Project", case = False, na = False))
games_2.loc[rp,['rating']] = 'E'


# Halo Triple Pack is rated M
halo = (games_2['name'].str.contains("Halo Triple Pack", case = False, na = False))
games_2.loc[halo,['rating']] = 'M'


# Xevious 3D/G+ is rated E
xe = (games_2['name'].str.contains("Xevious 3D", case = False, na = False))
games_2.loc[xe,['rating']] = 'E'


# Epidemic is rated E
ep = (games_2['name'].str.contains("Epidemic", case = False, na = False))
games_2.loc[ep,['rating']] = 'E'


# In the Hunt is rated E
ith = (games_2['name'].str.contains("In the Hunt", case = False, na = False))
games_2.loc[ith,['rating']] = 'E'


# Fuse (Insomniac) is rated 'M'
fuse = (games_2['name'].str.contains("Fuse ", case = False, na = False))
games_2.loc[fuse,['rating']] = 'M'


# Maximum Force is rated M
mf = (games_2['name'].str.contains("Maximum Force", case = False, na = False))
games_2.loc[mf,['rating']] = 'M'


# Jupiter Strike is rated E
js = (games_2['name'].str.contains("Jupiter Strike", case = False, na = False))
games_2.loc[js,['rating']] = 'E'


# Invasion From Beyond is rated E
ifb = (games_2['name'].str.contains("Invasion From Beyond", case = False, na = False))
games_2.loc[ifb,['rating']] = 'E'

# Codename Tenka is rated M
cnt = (games_2['name'].str.contains("Codename Tenka", case = False, na = False))
games_2.loc[cnt,['rating']] = 'M'


# Tempest 3X is rated E
temp = (games_2['name'].str.contains("tempest 3x", case = False, na = False))
games_2.loc[temp,['rating']] = 'E'


# G Darius is rated E
gd = (games_2['name'].str.contains("G Darius", case = False, na = False))
games_2.loc[gd,['rating']] = 'E'


# Viewpoint is rated E
vp = (games_2['name'].str.contains("Viewpoint", case = False, na = False))
games_2.loc[vp,['rating']] = 'E'

# DefCon 5 is rated E
def5 = (games_2['name'].str.contains("DefCon 5", case = False, na = False))
games_2.loc[def5,['rating']] = 'E'

# R-Types is rated E
rt = (games_2['name'].str.contains("R-Types", case = False, na = False))
games_2.loc[rt,['rating']] = 'E'

# Star Fighter is rated E
sf = (games_2['name'].str.contains("Star Fighter", case = False, na = False))
games_2.loc[sf,['rating']] = 'E'

#Thunder Force V: Perfect System is rated E
tf = (games_2['name'].str.contains("Thunder Force V:", case = False, na = False))
games_2.loc[tf,['rating']] = 'E'

# Magic Carpet is rated E
mc = (games_2['name'].str.contains("Magic Carpet", case = False, na = False))
games_2.loc[mc,['rating']] = 'E'

# Battle Rage is rated E10
br = (games_2['name'].str.contains("Battle Rage", case = False, na = False))
games_2.loc[br,['rating']] = 'E10+'

# Novastorm is rated E
ns = (games_2['name'].str.contains("Novastorm", case = False, na = False))
games_2.loc[ns,['rating']] = 'E'

# Painkiller: Hell & Damnation	is rated M
hd = (games_2['name'].str.contains("Painkiller: Hell & Damnation", case = False, na = False))
games_2.loc[hd,['rating']] = 'M'


# PO'ed is rated M
pod = (games_2['name'].str.contains("PO'ed", case = False, na = False))
games_2.loc[pod,['rating']] = 'M'


# Wicked Monster Blast! is rated E10
wmb = (games_2['name'].str.contains("Wicked Monster", case = False, na = False))
games_2.loc[wmb,['rating']] = 'E10+'

# SD Gundam Force: Showdown! is rated E
sdg = (games_2['name'].str.contains("SD Gundam Force: Showdown!", case = False, na = False))
games_2.loc[sdg,['rating']] = 'E'

# PowerSlave is rated M
ps = (games_2['name'].str.contains("PowerSlave", case = False, na = False))
games_2.loc[ps,['rating']] = 'M'

# Lethal Enforcers I & II is rated M
le = (games_2['name'].str.contains("Lethal Enforcers I & II", case = False, na = False))
games_2.loc[le,['rating']] = 'M'

# ['BRAHMA Force: The Assault on Beltlogger 9','Nanotek Warrior','R-Type Delta','Shooter: Starfighter Sanvein'] are E rated 
bnrs = games_2['name'].isin(['BRAHMA Force: The Assault on Beltlogger 9','Nanotek Warrior','R-Type Delta','Shooter: Starfighter Sanvein'])
games_2.loc[bnrs,['rating']] = 'E'


# The rest are rated T
tshoo = (games_2['genre'] == 'Shooter') & (games_2['rating'].isna())
games_2.loc[tshoo,['rating']] = 'T'

games.info()

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 12 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   name             16711 non-null  object 
 1   platform         16711 non-null  object 
 2   year_of_release  16565 non-null  float64
 3   genre            16711 non-null  object 
 4   na_sales         16711 non-null  float64
 5   eu_sales         16711 non-null  float64
 6   jp_sales         16711 non-null  float64
 7   other_sales      16711 non-null  float64
 8   critic_score     8135 non-null   float64
 9   user_score       7588 non-null   float64
 10  rating           10384 non-null  object 
 11  total_sales      16711 non-null  float64
dtypes: float64(8), object(4)
memory usage: 1.7+ MB

# Look at the missing games
games_2[(games_2['rating'].isna()) & (games_2['na_sales'] > 1)]



# All Rugrats games are rated E
rugrats = (games_2['name'].str.contains("Rugrats", case = False, na = False))
games_2.loc[rugrats,['rating']] = 'E'

# All command & conquer games are rated T
tw = (games_2['name'].str.contains("command & conquer 3: t", case = False, na = False))
games_2.loc[tw,['rating']] = 'T'

cc = (games_2['name'].str.contains("command & conquer", case = False, na = False))
games_2.loc[cc,['rating']] = 'T'


# T rated games
tmill = games_2['name'].isin(['Warzone 2100','Warcraft II: Tides of Darkness','Army Men 3D'])
games_2.loc[tmill,['rating']] = 'T'

# Devil May Cry is rated M
dmc = (games_2['name'].str.contains("devil may cry", case = False, na = False))
games_2.loc[dmc,['rating']] = 'M'


# E10 rated games
emill = games_2['name'].isin(['The Legend of Zelda: Ocarina of Time','Dollar Dash']) & (games_2['platform'] != 'N64')
games_2.loc[emill,['rating']] = 'E10+'


# The rest are rated E
emillion = (games_2['rating'].isna()) & (games_2['na_sales'] > 0.95)
games_2.loc[emillion,['rating']] = 'E'


games_2[(games_2['rating'].isna()) & (games_2['na_sales'] > 0.95)]
#games_2[(games_2['name'].str.contains("devil may cry", case = False, na = False))]

games_2[(games_2['rating'].isna()) & (games_2['na_sales'] > 0.8)]

# Jampack games have no rating
jam = (games_2['name'].str.contains("jampack", case = False, na = False))
games_2.loc[jam,['rating']] = 'No Rating: Country Exclusive'

# Let's look at more misc games
games_2[(games_2['rating'].isna()) & (games_2['genre'] == 'Misc')]

# High school musical games are rated E
hsm = (games_2['name'].str.contains("high school musical", case = False, na = False))
games_2.loc[hsm,['rating']] = 'E'

# Most disney games are rated E
disney = (games_2['name'].str.contains("disney", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[disney,['rating']] = 'E'

# The rest of the World Championship games are rated T
poker = (games_2['name'].str.contains("World Championship", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[poker,['rating']] = 'T'

# Midway game is rated E
mid = (games_2['name'].str.contains("midway", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[mid,['rating']] = 'E'

# Activision game is rated E
av = (games_2['name'].str.contains("activision", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[av,['rating']] = 'E'

# Jeopardy games are rated E
jep = (games_2['name'].str.contains("jeopardy", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[jep,['rating']] = 'E'

# Caesars games rated E
cae = (games_2['name'].str.contains("caesars", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[cae,['rating']] = 'E'


# Life games rated E
life = (games_2['name'].str.contains("life", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[life,['rating']] = 'E'

# Jump star is EC
jump = (games_2['name'].str.contains("jump start", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[jump,['rating']] = 'EC'

# Sonic Hero games rated E
sh = (games_2['name'].str.contains("sonic hero", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[sh,['rating']] = 'E'

# Buzz junior rob is E
bjr = (games_2['name'].str.contains("buzz! junior: robo", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[bjr,['rating']] = 'E'

# Buzz > 0 and < .45 in eu_sales is rated E10
buzzt = (games_2['name'].str.contains("buzz!", case = False, na = False)) & (games_2['rating'].isna()) & (games_2['eu_sales'] > 0) & (games_2['eu_sales'] < .45)
games_2.loc[buzzt,['rating']] = 'E10+'

# The remaining buzz games are T
buzz = (games_2['name'].str.contains("buzz!", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[buzz,['rating']] = 'T'

# Dancing with the Stars is rated E10
dws = (games_2['name'].str.contains("Dancing with the Stars: We Dance!", case = False, na = False))
games_2.loc[dws,['rating']] = 'E10+'

# Monopoly party is rated E
mp = (games_2['name'].str.contains("monopoly party", case = False, na = False))
games_2.loc[mp,['rating']] = 'E'


# pinball games rated E
pin = (games_2['name'].str.contains("pinball", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[pin,['rating']] = 'E'

# Rabbids is E10
rab = (games_2['name'].str.contains("rabbids", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[rab,['rating']] = 'E10+'

# Karaoke Revolution is T rated
kr = (games_2['name'].str.contains("Karaoke Revolution", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[kr,['rating']] = 'T'


# Michael Jackson is E10 rated
mj = (games_2['name'].str.contains("Michael Jackson", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[mj,['rating']] = 'E10+'


# Let's Cheer is rated E10
lc = (games_2['name'].str.contains("Let's Che", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[lc,['rating']] = 'E10+'

# ['Scene It? Bright Lights! Big Screen!',''] = T
si = games_2['name'] == 'Scene It? Bright Lights! Big Screen!'
games_2.loc[si,['rating']] = 'T'

# World Series of Poker: Tournamen... is rated T
wst = (games_2['name'].str.contains("World Series of Poker: Tournam", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[wst,['rating']] = 'T'


# Rhythm Thief & the Emperor's Trea... is E10
rt = (games_2['name'].str.contains("Rhythm Thief", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[rt,['rating']] = 'E10+'


# whacked is rated T
whack = (games_2['name'].str.contains("whacked", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[whack,['rating']] = 'T'


# Dungeons & Dragons is rated T
dd = (games_2['name'].str.contains("dungeons & dragons", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[dd,['rating']] = 'T'


# Payout Poker is rated T
pp = (games_2['name'].str.contains("Payout Poke", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[pp,['rating']] = 'T'


# The rest of the misc games are likely E
misce = (games_2['rating'].isna()) & (games_2['genre'] == 'Misc')
games_2.loc[misce,['rating']] = 'E'


games_2[(games_2['rating'].isna()) & (games_2['genre'] == 'Misc')]

# Go Diego go games are E rated
gdg = (games_2['name'].str.contains("go diego go", case = False, na = False))
games_2.loc[gdg,['rating']] = 'E'

# The remaining x-men games are rated M
xmen = (games_2['name'].str.contains("x-men", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[xmen,['rating']] = 'M'

# The remaining godfather games are rated M
godfather = (games_2['name'].str.contains("godfather", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[godfather,['rating']] = 'M'


# Avatar: The Game is rated T
avatar = (games_2['name'].str.contains("avatar: the game", case = False, na = False)) & (games_2['platform'] != 'DS')
games_2.loc[avatar,['rating']] = 'T'


# Avatar the last airbender is rated E10
atlab = (games_2['name'].str.contains("avatar: the last", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[atlab,['rating']] = 'E10+'


# All tiny toon games rated E
tt = (games_2['name'].str.contains("tiny toon", case = False, na = False))
games_2.loc[tt,['rating']] = 'E'


# M rated games
#['Dino Crisis','Fear Effect','Nightmare Creatures','Evil Dead: Fistfull of Boomstick','Deathtrap Dungeon','N3: Ninety-Nine Nights','Shadow Man','Spawn the Eternal','Covert Ops: Nuclear Dawn']
mact = games_2['name'].isin(['Dino Crisis','Fear Effect','Nightmare Creatures','Evil Dead: Fistfull of Boomstick','Deathtrap Dungeon',
                             'N3: Ninety-Nine Nights','Shadow Man','Spawn the Eternal','Covert Ops: Nuclear Dawn','Saw II: Flesh & Blood',
                             'The Crow: City of Angels','Rising Zan: The Samurai Gunman','Nightmare Creatures II','N3 II: Ninety-Nine Nights',
                             'Reloaded','Watchmen: The End is Nigh - The Complete Experience','Bio FREAKS','Urban Chaos','Watchmen: The End is Nigh Part 1 & 2',
                            'Broken Helix','Beatdown: Fists of Vengeance','Fuun Shinsengumi Bakumatsuden Portable'])

games_2.loc[mact,['rating']] = 'M'


# E10 rated games
#['Ratchet & Clank Collection','Monster Hunter X','Book of Spells','And1 Streetball','The Grim Adventures of Billy & Mandy','Spider-Man: Web of Shadows - Amazing Allies Edition']
e10act = games_2['name'].isin(['Ratchet & Clank Collection','Monster Hunter X','Book of Spells','And1 Streetball','The Grim Adventures of Billy & Mandy',
                               'Spider-Man: Web of Shadows - Amazing Allies Edition','Teenage Mutant Ninja Turtles (3DS)','NHL Legacy','Downstream Panic!'])

games_2.loc[e10act,['rating']] = 'E10+'


# T rated games

tact = (games_2['rating'].isna()) & (games_2['genre'] == 'Action') & (games_2['total_sales'] > 0.67) & (games_2['total_sales'] < 1.04)
games_2.loc[tact,['rating']] = 'T'

tact1 = (games_2['rating'].isna()) & (games_2['genre'] == 'Action') & (games_2['total_sales'] > 0.435) & (games_2['total_sales'] < 0.475)
games_2.loc[tact1,['rating']] = 'T'

tact2 = (games_2['rating'].isna()) & (games_2['genre'] == 'Action') & (games_2['total_sales'] > 0.34) & (games_2['total_sales'] < 0.375)
games_2.loc[tact2,['rating']] = 'T'

tact3 = (games_2['rating'].isna()) & (games_2['genre'] == 'Action') & (games_2['na_sales'] > 0.5)
games_2.loc[tact3,['rating']] = 'T'

tact4 = (games_2['rating'].isna()) & (games_2['genre'] == 'Action') & (games_2['name'].isin(['Tomb Raider Chronicles',
                                                                                             "Army Men: Sarge's Heroes",'Fighting Force 2','Grudge Warriors',
                                                                                            'Prince of Persia Trilogy','Tiny Tank','Fade to Black',
                                                                                             'Army Men World War: Land, Sea, Air','Star Trek: The Game',
                                                                                            'Wild 9','Perfect Weapon','Critical Depth','Rampage 2: Universal Tour',
                                                                                            'Jackie Chan: Stuntmaster','OverBlood','Treasures of the Deep',
                                                                                             'Silent Bomber','Shadow Madness','Time Commando',
                                                                                             'Wing Commander III: Heart of the Tiger',
                                                                                             "T'ai Fu: Wrath of the Tiger", 'The Fifth Element',
                                                                                             'Assault: Retribution','ToeJam & Earl III: Mission to Earth',
                                                                                             'Dragonseeds','Army Men World War: Team Assault',
                                                                                            'Action Man-Operation Extreme','Cyberia','Auto Destruct',
                                                                                            'Uprising X','Firefighter F.D.18','Secret Service: Ultimate Sacrifice',
                                                                                            'Prinny: Can I Really Be The Hero? (US sales)',
                                                                                             'G-Police: Weapons of Justice','Expendable',
                                                                                             'Roswell Conspiracies: Aliens, Myths & Legends','Raw Danger!',
                                                                                            'DragonHeart: Fire & Steel']))
games_2.loc[tact4,['rating']] = 'T'




# The rest should be E rated 
eact = (games_2['rating'].isna()) & (games_2['genre'] == 'Action')
games_2.loc[eact,['rating']] = 'E'

# Look at missing simulation games

# the missing the sims games are rated T
sims = (games_2['name'].str.contains("the sims", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[sims,['rating']] = 'T'

# Most of these simulation games are rated T; some are rated E
esim = (games_2['name'].isin(['Petz Sports','EyePet & Friends','Our House Party!',"NTRA Breeders' Cup World Thoroughbred Championships",
                              'Funky Barn','R/C Stunt Copter','A-Train',"Sid Meier's Railroads!",'Bogey: Dead 6','Gunship','Darklight Conflict','TigerShark']))

games_2.loc[esim,['rating']] = 'E'

# E10
e10sim = (games_2['name'].isin(['The Oregon Trail']))
games_2.loc[e10sim,['rating']] = 'E10+'

# Some games not rated 

nott = (games_2['name'].isin(['There','ThunderStrike 2']))
games_2.loc[nott,['rating']] = 'No Rating: Country Exclusive'



# The rest of the games appear to be rated 'T'
tsim = (games_2['rating'].isna()) & (games_2['genre'] == 'Simulation')
games_2.loc[tsim,['rating']] = 'T'

# Check R-P games

# The rest of the lord of the rings games are rated T
lor = (games_2['name'].str.contains("lord of the rings", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[lor,['rating']] = 'T'

# wild arms games are rated E
wa = (games_2['name'].str.contains("wild arms", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[wa,['rating']] = 'E'

# yokai games are rated E10+
yok = (games_2['name'].str.contains("yokai", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[yok,['rating']] = 'E10+'


# Most of the atelier games are rated T
atli = (games_2['name'].str.contains("Atelier", case = False, na = False)) & (games_2['rating'].isna()) & (games_2['total_sales'] > 0.23)
games_2.loc[atli,['rating']] = 'T'

atlid = (games_2['name'].str.contains("Atelier", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[atlid,['rating']] = 'E10+'


# There are some E-rated games
erp = games_2['name'].isin(['Legend of Legaia','Suikoden','Beyond The Beyond','Threads of Fate','Space Griffon VF-9','The Granstream Saga','Azure Dreams',
                           "Guardian's Crusade",'Ogre Battle Series: Tactics Ogre','The Nightmare of Druaga: Fushigino Dungeon','Tail of the Sun'])
games_2.loc[erp,['rating']] = 'E'

# There are some E10 games
e10rp = games_2['name'].isin(['Adventures to Go!','Brave Story: New Traveler (US sales)'])
games_2.loc[e10rp,['rating']] = 'E10+'

# There are some M rated games
mrp = games_2['name'].isin(['Dragon Age Origins: Awakening','Vandal Hearts','Blood Omen: Legacy of Kain','The Rise of the Argonauts','Koudelka',
                            'Deception III: Dark Delusion'])
games_2.loc[mrp,['rating']] = 'M'


# There are some games with no rating
nrrp = games_2['name'].isin(['Angel Blade: Neo Tokyo Guardians','Ogre Battle Saga Episode Five: The March of the Black Queen',
                             'Royal Palace of White Sword and The City of Gentiles','Ragnarok: Hikari to Yami no Koujo'])
games_2.loc[nrrp,['rating']] = 'No Rating: Country Exclusive'


# The rest appear to be rated T
trp = (games_2['rating'].isna()) & (games_2['genre'] == 'Role-Playing')
games_2.loc[trp,['rating']] = 'T'

# Let's look at strategy games

# The rest of the Yu-gi-oh games are rated E
yu_gi = (games_2['name'].str.contains("Yu-Gi-Oh", case = False, na = False)) & (games_2['rating'].isna())
games_2.loc[yu_gi,['rating']] = 'E'

# Some games are rated M
mstrat = (games_2['name'].isin(['Kagero: Deception II','Vandal Hearts II']))
games_2.loc[mstrat,['rating']] = 'M'

# some games are rated E
estrat = (games_2['name'].isin(['Warcraft: Orcs & Humans','Worms Armageddon','Civilization II','Panzer General','Kartia: The Word of Fate','Allied General',
                                'Chessmaster II','Railroad Tycoon II','Carnage Heart','LEGO Rock Raiders','Chess','X-COM: UFO Defense','Return Fire',
                                'RollerCoaster Tycoon 3: Platinum',"Defendin' De Penguin",'Battle Hunter','Master of Monsters: Disciples of Gaia',"Builder's Block"]))
games_2.loc[estrat,['rating']] = 'E'

eestrat = (games_2['rating'].isna()) & (games_2['genre'] == 'Strategy') & (games_2['total_sales'] > 0.58)
games_2.loc[eestrat,['rating']] = 'E'


# Some Sid Meier's Pirates games are rated E10
sm = (games_2['name'].str.contains("Sid Meier's Pirates", case = False, na = False)) & (games_2['rating'].isna()) & (games_2['total_sales'] > 0.155)
games_2.loc[sm,['rating']] = 'E10+'

e10strat = games_2['name'].isin(['R-Type Command (correct US sales)','The Legend of Korra (3DS)'])
games_2.loc[e10strat,['rating']] = 'E10+'


# The rest are rated T
tstrat = (games_2['rating'].isna()) & (games_2['genre'] == 'Strategy')
games_2.loc[tstrat,['rating']] = 'T'

# Let's look at adventure games

# Some games have no rating
noad = (games_2['name'].isin(['Parfait: Chocolat Second Style']))
games_2.loc[noad,['rating']] = 'No Rating: Country Exclusive'

# Some games are rated M
mad = (games_2['name'].isin(['Clock Tower','Prince of Persia: Revelations','Galerians','Corpse Party: Back to School Edition','Chronicles of the Sword',
                             'Crusader: No Remorse',"Blood Will Tell: Tezuka Osamu's Dororo",'Hakuouki: Shinsengumi Kitan','Psychic Detective']))
games_2.loc[mad,['rating']] = 'M'

# Some games are rated E10
e10ad = (games_2['name'].isin(['Chibi-Robo! Plug into Adventure!','Hidden Mysteries: Titanic - Secrets of the Fateful Voyage']))
games_2.loc[e10ad,['rating']] = 'E10+'

# Some games are rated T
tad = (games_2['name'].isin(['The ICO & Shadow of the Colossus Collection','Xena: Warrior Princess','The X Files','Beyond Good & Evil',
                             "Alone in the Dark: One-Eyed Jack's Revenge",'Shadow Master',"Dragon's Lair Trilogy",'Sam & Max: Season One',
                             'T.R.A.G. - Tactical Rescue Assault Group: Mission of Mercy','Echo Night','O.D.T.: Escape... Or Die Trying','Discworld',
                             'Broken Sword II: The Smoking Mirror','Sam & Max: Beyond Time and Space','In Cold Blood','Voodoo Chronicles: First Sign',
                             'Largo Winch .// Commando Sar','Discworld II: Mortality Bytes!']))
games_2.loc[tad,['rating']] = 'T'

# The rest are E rated 
ead = (games_2['rating'].isna()) & (games_2['genre'] == 'Adventure')
games_2.loc[ead,['rating']] = 'E'

games_2.info()

# We will leave user_score and critic_score alone for now

games_3 = games_2.copy()
games_3

<class 'pandas.core.frame.DataFrame'>
Index: 16711 entries, 0 to 16714
Data columns (total 17 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   name                16711 non-null  object 
 1   platform            16711 non-null  object 
 2   year_of_release     16683 non-null  float64
 3   genre               16711 non-null  object 
 4   na_sales            16711 non-null  float64
 5   eu_sales            16711 non-null  float64
 6   jp_sales            16711 non-null  float64
 7   other_sales         16711 non-null  float64
 8   critic_score        8135 non-null   float64
 9   user_score          7588 non-null   float64
 10  rating              16711 non-null  object 
 11  total_sales         16711 non-null  float64
 12  critic_score_group  8370 non-null   object 
 13  user_score_group    7823 non-null   object 
 14  total_sales_group   16711 non-null  object 
 15  era                 16683 non-null  object 
 16  esrb_era            16683 non-null  object 
dtypes: float64(8), object(9)
memory usage: 2.3+ MB

missing = games_3[games_3['user_score'].isna()]
total_million = missing[missing['total_sales'] >= 1]
total_less = missing[missing['total_sales'] < 1]


display(missing['era'].value_counts())
display(missing['genre'].value_counts())
display(missing['platform'].value_counts())
display(missing['rating'].value_counts())

display(total_million['rating'].value_counts())
display(total_less['rating'].value_counts())

era
2000's    4387
2010's    2808
90's      1682
80's       218
Name: count, dtype: int64

genre
Action          1539
Misc            1311
Sports          1245
Adventure       1003
Role-Playing     755
Racing           608
Simulation       529
Platform         460
Puzzle           452
Fighting         450
Shooter          399
Strategy         372
Name: count, dtype: int64

platform
DS      1635
PS      1035
PS2      920
PSP      789
Wii      760
GBA      567
PS3      454
3DS      346
N64      319
X360     295
PSV      287
SNES     239
XB       238
PC       204
GC       190
SAT      173
PS4      135
2600     133
GB        98
NES       98
XOne      65
WiiU      47
DC        38
GEN       27
NG        12
SCD        6
WS         6
3DO        3
TG16       2
GG         1
PCFX       1
Name: count, dtype: int64

rating
E                               3621
No Rating: Country Exclusive    2892
T                               1161
E10+                             597
M                                338
No Rating: Pre-ESRB              306
EC                               208
Name: count, dtype: int64

rating
E                               361
T                               110
No Rating: Pre-ESRB             103
M                                40
E10+                             39
No Rating: Country Exclusive     36
EC                                4
Name: count, dtype: int64

rating
E                               3260
No Rating: Country Exclusive    2856
T                               1051
E10+                             558
M                                298
EC                               204
No Rating: Pre-ESRB              203
Name: count, dtype: int64

ogmissing = games[games['user_score'].isna()]
display(ogmissing['year_of_release'].value_counts())
display(ogmissing['genre'].value_counts())
display(ogmissing['platform'].value_counts())
display(ogmissing['rating'].value_counts())

ogmissing[ogmissing['total_sales'] <= 0.5]
ogmissing[ogmissing['total_sales'] > 0.5]


games[games['total_sales'] > 0.5]

year_of_release
2009.0    814
2010.0    794
2008.0    773
2011.0    645
2007.0    569
2006.0    458
2002.0    367
2005.0    358
1998.0    348
2012.0    317
2015.0    309
1999.0    308
2004.0    274
1997.0    271
2003.0    261
1996.0    255
2014.0    252
2000.0    244
2013.0    241
2016.0    240
2001.0    227
1995.0    219
1994.0    121
1993.0     60
1981.0     46
1992.0     42
1991.0     41
1982.0     36
1986.0     21
1989.0     17
1983.0     17
1987.0     16
1990.0     16
1988.0     14
1984.0     14
1985.0     13
1980.0      9
Name: count, dtype: int64

genre
Action          1539
Misc            1311
Sports          1245
Adventure       1003
Role-Playing     755
Racing           608
Simulation       529
Platform         460
Puzzle           452
Fighting         450
Shooter          399
Strategy         372
Name: count, dtype: int64

platform
DS      1635
PS      1035
PS2      920
PSP      788
Wii      760
GBA      567
PS3      454
3DS      346
N64      319
X360     296
PSV      287
SNES     239
XB       238
PC       204
GC       190
SAT      173
PS4      135
2600     133
GB        98
NES       98
XOne      65
WiiU      47
DC        38
GEN       27
NG        12
SCD        6
WS         6
3DO        3
TG16       2
GG         1
PCFX       1
Name: count, dtype: int64

rating
E       1772
T        518
E10+     426
M        126
EC         9
K-A        1
RP         1
Name: count, dtype: int64

# Continue understanding the data

display(games_3['year_of_release'].value_counts().sort_index())
games_3['era'].value_counts()

year_of_release
1980.0      24
1981.0      46
1982.0      36
1983.0      17
1984.0      14
1985.0      14
1986.0      21
1987.0      16
1988.0      15
1989.0      17
1990.0      16
1991.0      41
1992.0      44
1993.0      60
1994.0     122
1995.0     219
1996.0     263
1997.0     289
1998.0     379
1999.0     340
2000.0     352
2001.0     490
2002.0     851
2003.0     787
2004.0     770
2005.0     962
2006.0    1028
2007.0    1202
2008.0    1450
2009.0    1448
2010.0    1278
2011.0    1164
2012.0     669
2013.0     548
2014.0     581
2015.0     607
2016.0     503
Name: count, dtype: int64

era
2000's    9340
2010's    5350
90's      1773
80's       220
Name: count, dtype: int64

# Create a DataFrame with game releases by year


# Writing and Speaking Beautiful Japanese DS has no rating
wsj = games_3['name'] == 'Writing and Speaking Beautiful Japanese DS'
games_3.loc[wsj,['rating']] = 'No Rating: Country Exclusive'
games_2.loc[wsj,['rating']] = 'No Rating: Country Exclusive'

# Sort the DataFrame by year_of_release
year_df = games_3.sort_values(by = 'year_of_release')
display(year_df)

year_df_og = games.sort_values(by = 'year_of_release')

# Visualize the distribution of games across years

year_group = year_df.groupby(['year_of_release'])['name'].count()
display(year_group)

year_group_og = year_df_og.groupby(['year_of_release'])['name'].count()

year_group.plot(title='Video Games Released Each Year',style = '-o',xlabel = 'year',ylabel= '# of video games',grid=True)

year_group_og.plot(title='Video Games Released Each Year',style = '-o',xlabel = 'year',ylabel= '# of video games',grid=True, alpha=0.4)

year_of_release
1980.0      24
1981.0      46
1982.0      36
1983.0      17
1984.0      14
1985.0      14
1986.0      21
1987.0      16
1988.0      15
1989.0      17
1990.0      16
1991.0      41
1992.0      44
1993.0      60
1994.0     122
1995.0     219
1996.0     263
1997.0     289
1998.0     379
1999.0     340
2000.0     352
2001.0     490
2002.0     851
2003.0     787
2004.0     770
2005.0     962
2006.0    1028
2007.0    1202
2008.0    1450
2009.0    1448
2010.0    1278
2011.0    1164
2012.0     669
2013.0     548
2014.0     581
2015.0     607
2016.0     503
Name: name, dtype: int64

<Axes: title={'center': 'Video Games Released Each Year'}, xlabel='year', ylabel='# of video games'>

# Using a histogram
games_3['year_of_release'].hist()

<Axes: >

year_group.plot(x='year_of_release',kind='bar', rot=90)

<Axes: xlabel='year_of_release'>

# Display summary statistics for each year


display(year_df.groupby('year_of_release')[['name','rating','platform','genre']].describe())
display(games.groupby('year_of_release')[['name','rating','platform','genre']].describe())

year_group.sort_values()

year_of_release
1985.0      14
1984.0      14
1988.0      15
1987.0      16
1990.0      16
1989.0      17
1983.0      17
1986.0      21
1980.0      24
1982.0      36
1991.0      41
1992.0      44
1981.0      46
1993.0      60
1994.0     122
1995.0     219
1996.0     263
1997.0     289
1999.0     340
2000.0     352
1998.0     379
2001.0     490
2016.0     503
2013.0     548
2014.0     581
2015.0     607
2012.0     669
2004.0     770
2003.0     787
2002.0     851
2005.0     962
2006.0    1028
2011.0    1164
2007.0    1202
2010.0    1278
2009.0    1448
2008.0    1450
Name: name, dtype: int64

display(year_df.groupby('year_of_release')[['user_score','critic_score']].describe())
display(year_df.groupby('year_of_release')[['na_sales','eu_sales']].describe())
display(year_df.groupby('year_of_release')[['jp_sales','other_sales']].describe())
display(year_df.groupby('year_of_release')['total_sales'].describe())

# Calculate total sales by platform and year

# Get the platform names
display(games_3['platform'].unique())


display(year_df.groupby(['era','platform'])['total_sales'].sum())
year_df.groupby(['year_of_release','platform'])['total_sales'].sum()

array(['Wii', 'NES', 'GB', 'DS', 'X360', 'PS3', 'PS2', 'SNES', 'GBA',
       'PS4', '3DS', 'N64', 'PS', 'XB', 'PC', '2600', 'PSP', 'XOne',
       'WiiU', 'GC', 'GEN', 'DC', 'PSV', 'SAT', 'SCD', 'WS', 'NG', 'TG16',
       '3DO', 'GG', 'PCFX'], dtype=object)

era     platform
2000's  3DS            0.02
        DC             7.41
        DS           680.96
        GB            29.00
        GBA          317.20
        GC           198.69
        N64           37.63
        PC            84.00
        PS           141.34
        PS2         1248.50
        PS3          346.44
        PSP          229.11
        WS             0.96
        Wii          681.03
        X360         416.65
        XB           257.74
2010's  3DS          258.70
        DS           124.89
        PC           125.48
        PS2            7.04
        PS3          592.50
        PS4          314.14
        PSP           64.59
        PSV           54.07
        Wii          225.77
        WiiU          82.19
        X360         554.70
        XOne         159.32
80's    2600          94.24
        DS             0.02
        GB            66.40
        NES          223.51
        PC             0.07
90's    2600           2.74
        3DO            0.10
        DC             8.54
        GB           159.03
        GEN           28.35
        GG             0.04
        N64          180.85
        NES           27.54
        NG             1.44
        PC            49.97
        PCFX           0.03
        PS           587.93
        SAT           33.59
        SCD            1.86
        SNES         200.04
        TG16           0.16
        WS             0.46
Name: total_sales, dtype: float64

year_of_release  platform
1980.0           2600        19.14
1981.0           2600        35.68
1982.0           2600        28.88
1983.0           2600         5.84
                 NES         10.96
                             ...  
2016.0           PSV          4.25
                 Wii          0.18
                 WiiU         4.60
                 X360         1.52
                 XOne        26.15
Name: total_sales, Length: 244, dtype: float64

platforms = games_3['platform'].unique()
years = games_3['year_of_release'].unique()

year_platform = year_df.groupby(['year_of_release','platform'])['total_sales'].sum()

year_platform_df = year_platform.reset_index()
year_platform_df['year_of_release'] = year_platform_df['year_of_release'].astype('int')
display(year_platform_df)


year_platform_pivot = games_3.pivot_table(index='platform',columns='year_of_release',values='total_sales',aggfunc='sum').fillna(0)
display(year_platform_pivot)

# Create a heatmap of platform sales over time

import matplotlib.pyplot as plt

plt.figure(figsize=(16,16))
plt.grid(alpha = 0.5)
plt.imshow(year_platform_pivot,cmap="gist_earth")



plt.xticks(ticks=range(len(year_platform_pivot.columns)), labels=year_platform_pivot.columns, rotation = 90)
plt.yticks(ticks=range(len(year_platform_pivot.index)), labels=year_platform_pivot.index)

plt.colorbar(label='Total Sales (Millions)')
plt.title('Platform Sales by Year Heatmap')
plt.xlabel('Year of Release')
plt.ylabel('Platform')
plt.tight_layout()
plt.show()

# Create another heatmap

year_platform_df.plot.scatter(x='year_of_release',
                              y='platform',
                              c="total_sales",
                              cmap="gist_earth_r",
                              s=year_platform_df['total_sales'] *5, 
                              figsize=(14,14),
                              grid=True,
                              alpha=0.5)

<Axes: xlabel='year_of_release', ylabel='platform'>

# Identify platforms with declining sales


display(year_platform_df[year_platform_df['year_of_release'] == 2006].sort_values(by='platform'))
display(year_platform_df[year_platform_df['year_of_release'] == 2009].sort_values(by='platform'))
display(year_platform_df[year_platform_df['year_of_release'] == 2013].sort_values(by='platform'))


        # DS        # 3DS      # PC       # PS2        # PS3        #PSP       # Wii       # X360     
# 2005 - 130.26        -        4.38        164.11       0.19        43.86         -        9.22
# 2006 - 120.05        -        2.85        104.78       20.96       56.29       140.19     51.79
# 2007 - 147.23        -        9.28        76.10        73.19       47.30       153.42     95.41
# 2008 - 145.96        -        12.46       55.02        121.17      36.76       179.77     139.41
# 2009 - 120.19        -        17.05       26.40        130.93      37.84       207.66     120.82
# 2010 - 85.35       0.30       26.15       6.59         143.13      35.04       129.36     170.73

# Look at sales from 2010 - 2015
display(year_platform_df[(year_platform_df['year_of_release'] > 2010) & (year_platform_df['year_of_release'] < 2017) 
    & (year_platform_df['platform'].isin(['3DS', 'DS', 'PC', 'PS2', 'PS3', 'PS4', 'PSP', 'PSV', 'Wii', 'WiiU', 'X360', 'XOne']
                                        ))].sort_values(by='platform'))

# Your code here to filter the dataset to relevant years
# Example:
# relevant_years = [XXXX, XXXX, XXXX] # Replace with your chosen years
# df_relevant = df[df['year_of_release'].isin(relevant_years)]
relevant_years=[2005,2006,2007,2008,2009, 2010,2011, 2012, 2013, 2014, 2015, 2016]
df_relevant = games_3[games_3['year_of_release'].isin(relevant_years)]
df_relevant

# Justify your choice with data
# I've made previous justifications in the previous summary

# Analyze platform sales trends
display(df_relevant.groupby(['platform','year_of_release'])['total_sales'].sum())

platform  year_of_release
3DS       2010.0              0.30
          2011.0             63.36
          2012.0             51.79
          2013.0             56.57
          2014.0             43.76
                             ...  
XB        2008.0              0.18
XOne      2013.0             18.96
          2014.0             54.07
          2015.0             60.14
          2016.0             26.15
Name: total_sales, Length: 112, dtype: float64

# Sort platforms by total sales
platform_sales = df_relevant.groupby(['platform','year_of_release'])['total_sales'].sum().sort_values()
platform_sales_df = platform_sales.reset_index()
display(platform_sales_df)

platform_total_sales = platform_sales_df.groupby('platform')['total_sales'].sum().sort_values()
platform_total_sales_df = platform_total_sales.reset_index()
display(platform_total_sales_df)

# Visualize top platforms
display(platform_sales_df[platform_sales_df['total_sales'] >= 25].plot(x='platform',y='total_sales',kind='bar', rot=90,figsize=(14,12)))

<Axes: xlabel='platform'>

# Visualize top platforms
display(platform_total_sales.plot(x='platform',y='total_sales',kind='bar'))

<Axes: xlabel='platform'>

# Calculate year-over-year growth for each platform

platform_rel_year_df = platform_sales_df.sort_values(by=['platform','year_of_release'])

platform_rel_year_df = platform_rel_year_df.reset_index()
platform_rel_year_df

# ((Starting value - final value) / starting value) * 100 : growth formula



def yearly_growth(df):
    first = [None]
    
    for i in range(1, len(df)):
        starting = df.iloc[i - 1]
        final = df.iloc[i]
        if (final['platform'] == starting['platform']):
            growth = ((final['total_sales'] - starting['total_sales']) / starting['total_sales']) * 100
            first.append(growth)
        else:
            first.append(None)
    return first

   
platform_rel_year_df['sales_growth_percent'] = yearly_growth(platform_rel_year_df)
platform_rel_year_df['sales_growth_percent'] = platform_rel_year_df['sales_growth_percent'].round(2)

display(platform_rel_year_df.head(60))

# Your code here to calculate and visualize platform growth rates
platform_rel_year_pivot = platform_rel_year_df.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')
display(platform_rel_year_pivot)

# Growth Chart: Lower Limit
platform_rel_year_pivot.plot(style='-o',figsize=(14,8),ylim=[-125,480], title = "Growth Percent - All Consoles: Lower Limit")

<Axes: title={'center': 'Growth Percent - All Consoles: Lower Limit'}, xlabel='year_of_release'>

# Separate PS3 and 3DS data
ps3_3ds = platform_rel_year_df[platform_rel_year_df['platform'].isin(['PS3','3DS'])]

# Top 5 grossing consoles
top5_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['PS2','DS','Wii','PS3','X360'])]

# Middle grossing consoles
middle_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['PS4','PSP','3DS','PC','XOne'])]

# Lower Grossing Consoles
lower_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['WiiU','XB','PSV','GBA','GC','DC'])]

# Wii Consoles
wii_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['WiiU','Wii'])]

# DS Consoles
ds_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['DS','3DS'])]

# Playstation Consoles
ps_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['PS4','PSP','PS2','PS3','PSV'])]

# Xbox Consoles
xb_consoles = platform_rel_year_df[platform_rel_year_df['platform'].isin(['XB','X360','XOne'])]


# Make pivot tables

# Only PS3 and DS
ps3_3ds_pivot = ps3_3ds.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# Top grossing consoles
top_5_consoles_pivot = top5_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# Middle Grossing Consoles
middle_consoles_pivot = middle_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# Lower Grossing Consoles
lower_consoles_pivot = lower_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# Wii Consoles
wii_consoles_pivot = wii_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# DS Consoles
ds_consoles_pivot = ds_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# Playstation Consoles
ps_consoles_pivot = ps_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')

# Xbox Consoles
xb_consoles_pivot = xb_consoles.pivot_table(index='year_of_release',columns='platform',values='sales_growth_percent')



# PS3 and DS chart
ps3_3ds_pivot.plot(style='-o',figsize=(14,8),grid=True,xticks=ps3_3ds['year_of_release'],alpha=0.7, title= "PS3 and DS: Growth Percent")
# Lower limites of PS3 and DS
ps3_3ds_pivot.plot(style='-o',figsize=(14,8),grid=True,xticks=ps3_3ds['year_of_release'],alpha=0.7, 
                   ylim = (-100,300),title = "PS3 and DS - Growth Percent: Lower Limit")

# Top grossing consoles chart: Lower Limit
# Refer to PS3 and DS Growth Percent Chart to see upper limits
top_5_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-100,480),xticks=top5_consoles['year_of_release'],
                          title= "Top Grossing Consoles - Lower Limit: Growth Percent")

# Middle Grossing Consoles
middle_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-100,300),xticks=middle_consoles['year_of_release'],
                          title= "Middle Grossing Consoles - Lower Limit: Growth Percent")

# Lower Grossing Consoles
lower_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-125,300),xticks=lower_consoles['year_of_release'],
                          title= " Lower Grossing Consoles: Growth Percent")

# Wii Consoles
wii_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-100,50),xticks=wii_consoles['year_of_release'],
                          title= "Wii Consoles: Growth Percent")


# DS Consoles
ds_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-100,50),xticks=ds_consoles['year_of_release'],
                          title= "DS Consoles - Lower Limit: Growth Percent")

# Playstation Consoles
ps_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-100,300),xticks=ps_consoles['year_of_release'],
                          title= "PlayStation Consoles - Lower Limit: Growth Percent")

# Xbox Consoles
xb_consoles_pivot.plot(style='-o',figsize=(14,8),grid=True,alpha=0.7, ylim=(-100,480),xticks=xb_consoles['year_of_release'],
                          title= "XBox Consoles - Lower Limit: Growth Percent")

<Axes: title={'center': 'XBox Consoles - Lower Limit: Growth Percent'}, xlabel='year_of_release'>

# Create box plot of sales by platform
sale_platform_df = games_3[['platform','total_sales']].dropna()
display(sale_platform_df)


sale_platform_df.boxplot(vert=False, by = 'platform',column = 'total_sales',figsize=(16,12))

<Axes: title={'center': 'total_sales'}, ylabel='platform'>

sale_platform_df.describe()

# Calculate detailed statistics for each platform

mean_sales = sale_platform_df.groupby('platform')['total_sales'].mean()

std_sales = sale_platform_df.groupby('platform')['total_sales'].std()

# Higher # = Higher Volatility
cv_sales = (std_sales/mean_sales * 100).round(2)

var_sales = sale_platform_df.groupby('platform')['total_sales'].var()

mode_sales = sale_platform_df.groupby('platform')['total_sales'].apply(mode)

min_sales = sale_platform_df.groupby('platform')['total_sales'].min()

q1_sales = sale_platform_df.groupby('platform')['total_sales'].quantile(0.25)

median_sales = sale_platform_df.groupby('platform')['total_sales'].median()

q3_sales = sale_platform_df.groupby('platform')['total_sales'].quantile(0.75)

max_sales = sale_platform_df.groupby('platform')['total_sales'].max()

iqr_sales = q3_sales-q1_sales

count = sale_platform_df.groupby('platform')['total_sales'].count()

unique = sale_platform_df.groupby('platform')['total_sales'].nunique()



# Add statistics to one DF

platform_ts_df = sale_platform_df.groupby('platform')['total_sales'].sum().reset_index()
display(platform_ts_df)

platform_ts_df  = platform_ts_df.merge(mean_sales.rename('mean_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(std_sales.rename('std_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(cv_sales.rename('cv_%_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(var_sales.rename('var_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(mode_sales.rename('mode_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(min_sales.rename('min_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(q1_sales.rename('q1_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(median_sales.rename('median_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(q3_sales.rename('q3_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(max_sales.rename('max_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(iqr_sales.rename('iqr_sales'),on='platform')
platform_ts_df  = platform_ts_df.merge(count.rename('count'),on='platform')
platform_ts_df  = platform_ts_df.merge(unique.rename('unique'),on='platform')

display(platform_ts_df)

# Choose a popular platform based on your previous analysis

# Single out the X360 data
x360 = games_3[games_3['platform'] == 'X360']
display(x360)

# Separate the needed columns, 
x360 = x360[['critic_score','user_score','total_sales']]
display(x360)

# Create scatter plots for both critic and user scores

# user_score
x360.plot(x='user_score',y='total_sales',kind='scatter', title = "User Score Impacts on X360 Sales", figsize=(10,10),grid=True, 
          yticks=[0,2,4,6,8,10,12,14,16,18,20,22,24],
          xticks=[0,10,20,30,40,50,60,70,80,90,100])

# critic_score
x360.plot(x='critic_score',y='total_sales',kind='scatter', title = "Critic Score Impact on X360 Sales", figsize = (10,10),grid=True, 
          yticks=[0,2,4,6,8,10,12,14,16,18,20,22,24],
          xticks=[0,10,20,30,40,50,60,70,80,90,100])

<Axes: title={'center': 'Critic Score Impact on X360 Sales'}, xlabel='critic_score', ylabel='total_sales'>

# Critic Scores
display(x360['critic_score'].describe())



# User Scores
display(x360['user_score'].describe())



# Total_sales
display(x360['total_sales'].describe())



# Calculate correlations
display("Critic Score Corrleation to TotalSales:", x360['critic_score'].corr(x360['total_sales']))
display("User Score Correlation to Total Sales:", x360['user_score'].corr(x360['total_sales']))

count    916.000000
mean      68.616812
std       15.016585
min       19.000000
25%       59.000000
50%       71.000000
75%       80.000000
max       98.000000
Name: critic_score, dtype: float64

count    966.000000
mean      66.835404
std       14.413322
min        7.000000
25%       59.000000
50%       70.000000
75%       78.000000
max       90.000000
Name: user_score, dtype: float64

count    1261.000000
mean        0.770349
std         1.616173
min         0.010000
25%         0.110000
50%         0.280000
75%         0.760000
max        21.820000
Name: total_sales, dtype: float64

'Critic Score Corrleation to TotalSales:'

np.float64(0.3937358653072587)

'User Score Correlation to Total Sales:'

np.float64(0.11445882978454187)

# Find games released on multiple platforms
platform_name = games_3[['name','platform','total_sales']].reset_index()

# Make all names lowercase
platform_name.iloc[0:16711,1] = platform_name['name'].str.lower()


# Search for duplicates
duplicated_names = platform_name[platform_name['name'].duplicated()]
duplicated_names

# put the duplicated names in a variable
duplicated_names1 = duplicated_names['name']

# Get ALL the duplicated names, not excluding the first duplicate
duplicated_names = platform_name[platform_name['name'].isin(duplicated_names1)]
duplicated_names

# sort the names
duplicated_names = duplicated_names.sort_values(by='name')
duplicated_names.reset_index()

display(duplicated_names)

# Look at how many platforms each game is on 
platform_counts = duplicated_names.groupby('name')['platform'].nunique()
display(platform_counts)

# Look at how many games are on each platform 
game_counts = duplicated_names.groupby('platform')['name'].nunique()
display(game_counts)

# Filter out games that are on less than 7 platforms
plus_7 = platform_counts[platform_counts >= 7]
display(plus_7)

name
 frozen: olaf's quest               2
007: quantum of solace              6
007: the world is not enough        2
11eyes: crossover                   2
18 wheeler: american pro trucker    2
                                   ..
zoo tycoon (2013)                   2
zoocube                             2
zumba fitness                       3
zumba fitness core                  2
zumba fitness: world party          2
Name: platform, Length: 2806, dtype: int64

platform
2600      17
3DS      145
DC         9
DS       546
GB        19
GBA      230
GC       427
GEN        8
N64       98
NES       27
NG         3
PC       511
PS       203
PS2     1047
PS3     1054
PS4      321
PSP      395
PSV      205
SAT       37
SNES      34
WS         2
Wii      687
WiiU     100
X360    1014
XB       594
XOne     224
Name: name, dtype: int64

name
angry birds star wars                             8
cars                                              8
fifa 12                                           7
fifa 14                                           9
fifa 15                                           8
fifa soccer 08                                    7
fifa soccer 10                                    7
fifa soccer 11                                    7
fifa soccer 13                                    8
harry potter and the half-blood prince            7
harry potter and the order of the phoenix         7
harry potter and the sorcerer's stone             7
lego batman 2: dc super heroes                    7
lego batman 3: beyond gotham                      8
lego batman: the videogame                        7
lego harry potter: years 5-7                      8
lego indiana jones: the original adventures       7
lego jurassic world                               8
lego marvel super heroes                          9
lego marvel's avengers                            7
lego pirates of the caribbean: the video game     7
lego star wars ii: the original trilogy           8
lego star wars iii: the clone wars                7
lego star wars: the force awakens                 7
lego the hobbit                                   8
lego the lord of the rings                        7
madden nfl 06                                     7
madden nfl 07                                     9
madden nfl 08                                     8
major league baseball 2k11                        7
monopoly                                          8
nba jam                                           7
need for speed carbon                             7
need for speed: most wanted                      10
need for speed: prostreet                         7
need for speed: undercover                        7
pro evolution soccer 2012                         7
ratatouille                                       9
skylanders swap force                             7
skylanders: superchargers                         7
skylanders: trap team                             7
spider-man 3                                      7
star wars the clone wars: republic heroes         7
surf's up                                         7
terraria                                          8
the amazing spider-man 2 (2014)                   7
the lego movie videogame                          8
the sims 2                                        7
tomb raider: legend                               7
wall-e                                            7
Name: platform, dtype: int64

# Filter the dataframe duplicated_names to reflect only the games on 7 or more platforms
plus_7_index = plus_7.index.unique()
display(plus_7_index)


plus_platforms = duplicated_names[duplicated_names['name'].isin(['angry birds star wars', 'cars', 'fifa 12', 'fifa 14', 'fifa 15',
       'fifa soccer 08', 'fifa soccer 10', 'fifa soccer 11', 'fifa soccer 13',
       'harry potter and the half-blood prince',
       'harry potter and the order of the phoenix',
       "harry potter and the sorcerer's stone",
       'lego batman 2: dc super heroes', 'lego batman 3: beyond gotham',
       'lego batman: the videogame', 'lego harry potter: years 5-7',
       'lego indiana jones: the original adventures', 'lego jurassic world',
       'lego marvel super heroes', "lego marvel's avengers",
       'lego pirates of the caribbean: the video game',
       'lego star wars ii: the original trilogy',
       'lego star wars iii: the clone wars',
       'lego star wars: the force awakens', 'lego the hobbit',
       'lego the lord of the rings', 'madden nfl 06', 'madden nfl 07',
       'madden nfl 08', 'major league baseball 2k11', 'monopoly', 'nba jam',
       'need for speed carbon', 'need for speed: most wanted',
       'need for speed: prostreet', 'need for speed: undercover',
       'pro evolution soccer 2012', 'ratatouille', 'skylanders swap force',
       'skylanders: superchargers', 'skylanders: trap team', 'spider-man 3',
       'star wars the clone wars: republic heroes', "surf's up", 'terraria',
       'the amazing spider-man 2 (2014)', 'the lego movie videogame',
       'the sims 2', 'tomb raider: legend', 'wall-e'])]
plus_platforms

Index(['angry birds star wars', 'cars', 'fifa 12', 'fifa 14', 'fifa 15',
       'fifa soccer 08', 'fifa soccer 10', 'fifa soccer 11', 'fifa soccer 13',
       'harry potter and the half-blood prince',
       'harry potter and the order of the phoenix',
       'harry potter and the sorcerer's stone',
       'lego batman 2: dc super heroes', 'lego batman 3: beyond gotham',
       'lego batman: the videogame', 'lego harry potter: years 5-7',
       'lego indiana jones: the original adventures', 'lego jurassic world',
       'lego marvel super heroes', 'lego marvel's avengers',
       'lego pirates of the caribbean: the video game',
       'lego star wars ii: the original trilogy',
       'lego star wars iii: the clone wars',
       'lego star wars: the force awakens', 'lego the hobbit',
       'lego the lord of the rings', 'madden nfl 06', 'madden nfl 07',
       'madden nfl 08', 'major league baseball 2k11', 'monopoly', 'nba jam',
       'need for speed carbon', 'need for speed: most wanted',
       'need for speed: prostreet', 'need for speed: undercover',
       'pro evolution soccer 2012', 'ratatouille', 'skylanders swap force',
       'skylanders: superchargers', 'skylanders: trap team', 'spider-man 3',
       'star wars the clone wars: republic heroes', 'surf's up', 'terraria',
       'the amazing spider-man 2 (2014)', 'the lego movie videogame',
       'the sims 2', 'tomb raider: legend', 'wall-e'],
      dtype='object', name='name')

# Compare sales across platforms for these games

# Make a pivot_table for duplicated_names - ALL duplicated games
duplicated_names_pivot = duplicated_names.pivot_table(index='platform',columns='name',values='total_sales')
duplicated_names_pivot



# Make a pivot table for games that are across 7 or more platforms
plus_platforms_pivot = plus_platforms.pivot_table(index='platform',columns='name',values='total_sales')
display(plus_platforms_pivot)

# Your code here to analyze and visualize cross-platform performance
plus_platforms_pivot.plot(kind='bar', figsize=(14,24))

<Axes: xlabel='platform'>

# Your code here to analyze and visualize cross-platform performance

# Further filter the data to (the above chart is nearly unreadable)
# star wars games
star_wars = plus_platforms[plus_platforms['name'].str.contains('star wars')]

# sports games - madden, major league baseball, nba, pro evolution soccer
sports = plus_platforms[plus_platforms['name'].str.contains(('nba|major|pro ev|madden'))]

# Fifa games
fifa = plus_platforms[plus_platforms['name'].str.contains(('fifa'))]

# harry potter
hp = plus_platforms[plus_platforms['name'].str.contains('harry potter')]

# Need for Speed
nfs = plus_platforms[plus_platforms['name'].str.contains('need for speed')]

# lego games
lego = plus_platforms[plus_platforms['name'].str.contains('lego ind|lego jur|lego pir|lego the hob|lego the lord|lego movie vid')]

lego1 = plus_platforms[plus_platforms['name'].str.contains('lego bat|lego marv')]

# Action games
action =  plus_platforms[plus_platforms['name'].str.contains('skylander|spider|tomb|terraria')]

# disney/kids/other games - cars, monopoly, ratatouille, surf's up, sims, wall-e
other = plus_platforms[plus_platforms['name'].str.contains('cars|monopoly|ratat|surf|sim|wall')]

# Make pivot_tables for each new filtered data we just created

star_wars_pivot = star_wars.pivot_table(index='platform',columns='name',values='total_sales')
sports_pivot = sports.pivot_table(index='platform',columns='name',values='total_sales')
fifa_pivot = fifa.pivot_table(index='platform',columns='name',values='total_sales')
hp_pivot = hp.pivot_table(index='platform',columns='name',values='total_sales')
nfs_pivot = nfs.pivot_table(index='platform',columns='name',values='total_sales')
lego_pivot = lego.pivot_table(index='platform',columns='name',values='total_sales')
lego1_pivot = lego1.pivot_table(index='platform',columns='name',values='total_sales')
action_pivot = action.pivot_table(index='platform',columns='name',values='total_sales')
other_pivot = other.pivot_table(index='platform',columns='name',values='total_sales')

# Make bar charts for each new filtered pivot table

# First Star Wars
star_wars_pivot.plot(kind='bar', figsize=(14,8), title= "Star Wars Game Sales on the Platform it was Produced",grid=True)

<Axes: title={'center': 'Star Wars Game Sales on the Platform it was Produced'}, xlabel='platform'>

# Look at Sports games
sports_pivot.plot(kind='bar', figsize=(14,8), title= "Sports Game Sales on the Platform it was Produced",grid=True)
fifa_pivot.plot(kind='bar', figsize=(14,8), title= "Fifa Game Sales on the Platform it was Produced", grid= True)

<Axes: title={'center': 'Fifa Game Sales on the Platform it was Produced'}, xlabel='platform'>

# Look at Harry Potter Games

hp_pivot.plot(kind='bar', figsize=(14,8), title= "Harry Potter Game Sales on the Platform it was Produced",grid=True)

<Axes: title={'center': 'Harry Potter Game Sales on the Platform it was Produced'}, xlabel='platform'>

# Look at the rest of the games

nfs_pivot.plot(kind='bar', figsize=(14,8), title= "Need for Speed Game Sales on the Platform it was Produced")
lego_pivot.plot(kind='bar', figsize=(14,8), title= "LEGO Game Sales on the Platform it was Produced")
lego1_pivot.plot(kind='bar', figsize=(14,8), title= "LEGO Batman & Marvel Game Sales on the Platform it was Produced")
action_pivot.plot(kind='bar', figsize=(14,8), title= "Action Game Sales on the Platform it was Produced",ylim=(0,1.5),grid=True)
other_pivot.plot(kind='bar', figsize=(14,8), title= "Pixar/Kid/Other Game Sales on the Platform it was Produced",grid=True)

<Axes: title={'center': 'Pixar/Kid/Other Game Sales on the Platform it was Produced'}, xlabel='platform'>

# Analyze genre performance

genre_sales = games_3.groupby('genre')['total_sales'].sum()
display(genre_sales)

genre_sales_mean = games_3.groupby('genre')['total_sales'].mean()
display(genre_sales_mean)

genre_sales_year = games_3.groupby(['genre','year_of_release'])['total_sales'].sum()

genre
Action          1744.17
Adventure        237.59
Fighting         447.53
Misc             802.51
Platform         827.29
Puzzle           242.57
Racing           728.67
Role-Playing     934.56
Shooter         1052.45
Simulation       389.97
Sports          1331.26
Strategy         174.23
Name: total_sales, dtype: float64

genre
Action          0.517711
Adventure       0.182341
Fighting        0.527126
Misc            0.458577
Platform        0.932683
Puzzle          0.418224
Racing          0.583403
Role-Playing    0.623872
Shooter         0.795503
Simulation      0.446701
Sports          0.567218
Strategy        0.255095
Name: total_sales, dtype: float64

# Sort genres by total sales

genre_sales = genre_sales.sort_values(ascending = False)
display(genre_sales)

# Reset the index
genre_sales = genre_sales.reset_index()
display(genre_sales)

genre
Action          1744.17
Sports          1331.26
Shooter         1052.45
Role-Playing     934.56
Platform         827.29
Misc             802.51
Racing           728.67
Fighting         447.53
Simulation       389.97
Puzzle           242.57
Adventure        237.59
Strategy         174.23
Name: total_sales, dtype: float64

# Sort genres by mean total sales

genre_sales_mean = genre_sales_mean.sort_values(ascending = False)
display(genre_sales_mean)

# Reset the index
genre_sales_mean = genre_sales_mean.reset_index()
display(genre_sales_mean)

genre
Platform        0.932683
Shooter         0.795503
Role-Playing    0.623872
Racing          0.583403
Sports          0.567218
Fighting        0.527126
Action          0.517711
Misc            0.458577
Simulation      0.446701
Puzzle          0.418224
Strategy        0.255095
Adventure       0.182341
Name: total_sales, dtype: float64

# Sort genres by year and  total sales

genre_sales_year = genre_sales_year.sort_values(ascending = False)
display(genre_sales_year)

# Reset the index
genre_sales_year = genre_sales_year.reset_index()
display(genre_sales_year)

genre       year_of_release
Action      2008.0             143.26
            2009.0             137.90
Sports      2006.0             137.57
            2009.0             137.37
Action      2012.0             123.91
                                ...  
Misc        1991.0               0.08
Adventure   1993.0               0.07
Simulation  1985.0               0.04
            1988.0               0.03
Puzzle      2016.0               0.01
Name: total_sales, Length: 390, dtype: float64

# Display total sales, mean total sales, and total sales per year

display(genre_sales)
display(genre_sales_mean)
display(genre_sales_year)

# Visualize genre distribution
genre_sales.plot(kind='bar',x= 'genre',legend=False, title = "Total Sale of Video Games By Genre")

genre_sales_mean.plot(kind = 'bar',x='genre',legend=False,title="Mean Sale of Video Games By Genre")

<Axes: title={'center': 'Mean Sale of Video Games By Genre'}, xlabel='genre'>

# Calculate market share for each genre

total_sales = games_3['total_sales'].sum()
display(total_sales)

genre_sales['market_share_%'] = (genre_sales['total_sales'] / total_sales) * 100

display(genre_sales)

np.float64(8912.8)

# Calculate market share for each genre per year


# Get the total sales for each year
total_sales1 = games_3.groupby('year_of_release')['total_sales'].sum()
display(total_sales1)

total_sales1 = total_sales1.reset_index()
display(total_sales1)

# Merge the total sales for each year into genre sales year

genre_sales_year_merge = genre_sales_year.merge(total_sales1,on='year_of_release',)

display(genre_sales_year_merge)

genre_sales_year_merge['market_share_%'] = (genre_sales_year_merge['total_sales_x'] / genre_sales_year_merge['total_sales_y'].values) * 100

display(genre_sales_year_merge)

#total_sales1['year_of_release'] == 1980

year_of_release
1980.0     19.14
1981.0     35.68
1982.0     28.88
1983.0     16.80
1984.0     50.35
1985.0     53.95
1986.0     37.08
1987.0     21.70
1988.0     47.21
1989.0     73.45
1990.0     49.37
1991.0     32.23
1992.0     76.37
1993.0     45.99
1994.0     81.76
1995.0     88.12
1996.0    199.15
1997.0    201.07
1998.0    256.31
1999.0    252.30
2000.0    201.98
2001.0    336.43
2002.0    403.70
2003.0    367.12
2004.0    420.79
2005.0    464.78
2006.0    524.06
2007.0    606.16
2008.0    690.77
2009.0    660.89
2010.0    596.65
2011.0    513.72
2012.0    361.41
2013.0    362.11
2014.0    331.53
2015.0    267.99
2016.0    129.98
Name: total_sales, dtype: float64

# Make a pivot_table to answer the questions below:
genre_sales_year_pivot = genre_sales_year_merge.pivot_table(index = 'year_of_release', columns = 'genre',values='total_sales_x')
genre_sales_year_pivot.plot(title = "Total Sales Change By Genre", 
                            figsize=(14,8),
                            xticks= genre_sales_year_merge['year_of_release'], 
                            rot=90, grid='vert', colormap='Paired',style='-o')

genre_market_year_pivot = genre_sales_year_merge.pivot_table(index = 'year_of_release', columns = 'genre',values='market_share_%')

genre_market_year_pivot.plot(title="Market Share Percent By Genre",
                             xticks= genre_sales_year_merge['year_of_release'],
                             figsize=(14,8),colormap = "Paired", 
                             rot=90, style= '-o')

<Axes: title={'center': 'Market Share Percent By Genre'}, xlabel='year_of_release'>

# Function to analyze platform performance by region

platforms_info = games_3[['platform','year_of_release','genre','na_sales','eu_sales','jp_sales','other_sales','total_sales','user_score','critic_score','rating']]

platforms_region = platforms_info[['platform','na_sales','eu_sales','jp_sales','other_sales','total_sales']]
display(platforms_region)

# Analyze each region
na_region = platforms_region[['platform','na_sales']]
eu_region = platforms_region[['platform','eu_sales']]
jp_region = platforms_region[['platform','jp_sales']]
other_region = platforms_region[['platform','other_sales']]
all_region = platforms_region[['platform','na_sales','eu_sales','jp_sales','other_sales']]

# Analyze NA region

# Make a pivot table for the NA Region

na_pivot = na_region.pivot_table(index='platform', values='na_sales',aggfunc='sum')

na_pivot.plot(kind='bar', figsize=(14,8), colormap = 'Spectral', title="North American Sales Across Platforms",grid=True)

<Axes: title={'center': 'North American Sales Across Platforms'}, xlabel='platform'>

# Make a pivot table for the EU Region

eu_pivot = eu_region.pivot_table(index='platform', values='eu_sales',aggfunc='sum')

eu_pivot.plot(kind='bar', figsize=(14,8), colormap = 'inferno_r', title="European Sales Across Platforms",grid=True)

<Axes: title={'center': 'European Sales Across Platforms'}, xlabel='platform'>

# Make a pivot table for the JP Region

jp_pivot = jp_region.pivot_table(index='platform', values='jp_sales',aggfunc='sum')

jp_pivot.plot(kind='bar', figsize=(14,8), colormap = 'Accent', title="Japanese Sales Across Platforms",grid=True)

<Axes: title={'center': 'Japanese Sales Across Platforms'}, xlabel='platform'>

# Make a pivot table for the Other Region


other_pivot = other_region.pivot_table(index='platform', values='other_sales',aggfunc='sum')

other_pivot.plot(kind='bar', figsize=(14,8), colormap = 'copper_r', title="Other Countries Sales Across Platforms (NOT NA, EU, or JP)",grid=True)

<Axes: title={'center': 'Other Countries Sales Across Platforms (NOT NA, EU, or JP)'}, xlabel='platform'>

# Make a pivot table with all countries

all_pivot = all_region.pivot_table(index='platform', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')

all_pivot.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="All Countries Sales Across Platforms (NA, EU, JP, & Other)",grid=True)

<Axes: title={'center': 'All Countries Sales Across Platforms (NA, EU, JP, & Other)'}, xlabel='platform'>

# Create a comparative platform analysis
display(all_region)

# Filter out the top 3 ranking consoles
top_platforms = ['PS2', 'PS3','X360','PS','DS']
all_region_filtered = all_region.query("platform == @top_platforms")[['platform','na_sales','eu_sales','jp_sales','other_sales']]

display(all_region_filtered)

# Visualize cross-regional comparison for top platforms
all_filtered_pivot = all_region_filtered.pivot_table(index='platform', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc=sum)

all_filtered_pivot.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Top Regional Sales Across Top Platforms (NA, EU, JP, & Other)",grid=True)

C:\Users\hdyec\AppData\Local\Temp\ipykernel_24232\3880087452.py:2: FutureWarning: The provided callable <built-in function sum> is currently using DataFrameGroupBy.sum. In a future version of pandas, the provided callable will be used directly. To keep current behavior pass the string "sum" instead.
  all_filtered_pivot = all_region_filtered.pivot_table(index='platform', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc=sum)

<Axes: title={'center': 'Top Regional Sales Across Top Platforms (NA, EU, JP, & Other)'}, xlabel='platform'>

# Look at top sales in all countries

all_grouped = platforms_region.query("platform == @top_platforms")
display(all_grouped)

# NA
na_grouped = all_grouped.groupby('platform')['na_sales'].sum()
na_grouped = na_grouped.reset_index()
display(na_grouped)

# JP
jp_grouped = all_grouped.groupby('platform')['jp_sales'].sum()
jp_grouped = jp_grouped.reset_index()
display(jp_grouped)

# EU
eu_grouped = all_grouped.groupby('platform')['eu_sales'].sum()
eu_grouped = eu_grouped.reset_index()
display(eu_grouped)

# Other
other_grouped = all_grouped.groupby('platform')['other_sales'].sum()
other_grouped = other_grouped.reset_index()
display(other_grouped)


# Total
total_grouped = all_grouped.groupby('platform')['total_sales'].sum()
total_grouped = total_grouped.reset_index()
display(total_grouped)


# All
all_top = na_grouped
all_top['jp_sales'] = jp_grouped['jp_sales']
all_top['eu_sales'] = eu_grouped['eu_sales']
all_top['other_sales'] = other_grouped['other_sales']
all_top['total_sales'] = total_grouped['total_sales']
all_top = all_top.sort_values(by='total_sales',ascending=False)
all_top = all_top.reset_index()

display(all_top)

# All platforms

all_grouped_plat = platforms_region.groupby('platform')['total_sales'].sum()
all_grouped_plat = all_grouped_plat.reset_index() 


all_grouped_plat_na = platforms_region.groupby('platform')['na_sales'].sum()
all_grouped_plat_na = all_grouped_plat_na.reset_index()


all_grouped_plat_jp = platforms_region.groupby('platform')['jp_sales'].sum()
all_grouped_plat_jp = all_grouped_plat_jp.reset_index()

all_grouped_plat_eu = platforms_region.groupby('platform')['eu_sales'].sum()
all_grouped_plat_eu = all_grouped_plat_eu.reset_index()

all_grouped_plat_other = platforms_region.groupby('platform')['other_sales'].sum()
all_grouped_plat_other = all_grouped_plat_other.reset_index()

all_grouped_plat['na_sales'] = all_grouped_plat_na['na_sales']
all_grouped_plat['eu_sales'] = all_grouped_plat_eu['eu_sales']
all_grouped_plat['jp_sales'] = all_grouped_plat_jp['jp_sales']
all_grouped_plat['other_sales'] = all_grouped_plat_other['other_sales']




# Mean Platform data

all_grouped_plat_na_mean = platforms_region.groupby('platform')['na_sales'].mean()
all_grouped_plat_na_mean = all_grouped_plat_na_mean.reset_index()
all_grouped_plat['na_mean'] = all_grouped_plat_na_mean['na_sales'].round(2)


all_grouped_plat_eu_mean = platforms_region.groupby('platform')['eu_sales'].mean()
all_grouped_plat_eu_mean = all_grouped_plat_eu_mean.reset_index()
all_grouped_plat['eu_mean'] = all_grouped_plat_eu_mean['eu_sales'].round(2)


all_grouped_plat_jp_mean = platforms_region.groupby('platform')['jp_sales'].mean()
all_grouped_plat_jp_mean = all_grouped_plat_jp_mean.reset_index()
all_grouped_plat['jp_mean'] = all_grouped_plat_jp_mean['jp_sales'].round(2)


all_grouped_plat_other_mean = platforms_region.groupby('platform')['other_sales'].mean()
all_grouped_plat_other_mean = all_grouped_plat_other_mean.reset_index()
all_grouped_plat['other_mean'] = all_grouped_plat_other_mean['other_sales'].round(2)




# Percent each region consumes for each Platform
all_grouped_plat['na_%'] = ((all_grouped_plat['na_sales'] / all_grouped_plat['total_sales']) * 100).round(2)
all_grouped_plat['jp_%'] = ((all_grouped_plat['jp_sales'] / all_grouped_plat['total_sales']) * 100).round(2)
all_grouped_plat['eu_%'] = ((all_grouped_plat['eu_sales'] / all_grouped_plat['total_sales']) * 100).round(2)
all_grouped_plat['other_%'] = ((all_grouped_plat['other_sales'] / all_grouped_plat['total_sales']) * 100).round(2)



# Sort by Sales

all_grouped_plat = all_grouped_plat.sort_values(by='total_sales',ascending = False)

all_grouped_plat_limited = all_grouped_plat[all_grouped_plat['platform'].isin(['PS2','X360','PS3','Wii','DS','PS','SNES','3DS','NES','GB','GEN','2600','PS4','XOne','WS'])]

display(all_grouped_plat)
display(all_grouped_plat_limited)


all_filtered_pivot.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Top Regional Sales Across Top Platforms (NA, EU, JP, & Other)",grid=True)

<Axes: title={'center': 'Top Regional Sales Across Top Platforms (NA, EU, JP, & Other)'}, xlabel='platform'>

# Function to analyze genre performance by region

genre_region = platforms_info[['genre','na_sales','eu_sales','jp_sales','other_sales','total_sales']]
display(genre_region)


# Analyze each region
na_region_gen = genre_region[['genre','na_sales']]
eu_region_gen = genre_region[['genre','eu_sales']]
jp_region_gen = genre_region[['genre','jp_sales']]
other_region_gen = genre_region[['genre','other_sales']]
all_region_gen = genre_region[['genre','na_sales','eu_sales','jp_sales','other_sales']]
all_region_gen_sales = genre_region[['genre','na_sales','eu_sales','jp_sales','other_sales','total_sales']]



# Analyze the regions

# Make a pivot table for the NA Region

na_pivot_gen = na_region_gen.pivot_table(index='genre', values='na_sales',aggfunc='sum')

na_pivot_gen.plot(kind='bar', figsize=(14,8), colormap = 'Spectral', title="North American Sales Across Genres",grid=True)




# Make a pivot table for the EU Region

eu_pivot_gen = eu_region_gen.pivot_table(index='genre', values='eu_sales',aggfunc='sum')

eu_pivot_gen.plot(kind='bar', figsize=(14,8), colormap = 'inferno_r', title="European Sales Across Genres",grid=True)


# Make a pivot table for the JP Region

jp_pivot_gen = jp_region_gen.pivot_table(index='genre', values='jp_sales',aggfunc='sum')

jp_pivot_gen.plot(kind='bar', figsize=(14,8), colormap = 'Accent', title="Japanese Sales Across Genres",grid=True,ylim=(100,150))


# Make a pivot table for the Other Region


other_pivot_gen = other_region_gen.pivot_table(index='genre', values='other_sales',aggfunc='sum')

other_pivot_gen.plot(kind='bar', figsize=(14,8), colormap = 'copper_r', title="Other Countries Sales Across Genres (NOT NA, EU, or JP)",grid=True)



# Make a pivot table with all countries

all_pivot_gen = all_region_gen.pivot_table(index='genre', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')

all_pivot_gen.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="All Countries Sales Across Genres (NA, EU, JP, & Other)",grid=True)

<Axes: title={'center': 'All Countries Sales Across Genres (NA, EU, JP, & Other)'}, xlabel='genre'>

# Create a comparative genre analysis

# Filter out the top 5 ranking genres
top_genres = ['Action','Sports','Shooter','Role-Playing','Platform','Misc','Racing']
all_region_filtered_gen = all_region_gen.query("genre == @top_genres")[['genre','na_sales','eu_sales','jp_sales','other_sales']]

display(all_region_filtered_gen)


# Visualize cross-regional comparison for top genres
all_filtered_pivot_gen = all_region_filtered_gen.pivot_table(index='genre', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc=sum)

all_filtered_pivot_gen.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Top Regional Sales By Genre (NA, EU, JP, & Other)",grid=True)

C:\Users\hdyec\AppData\Local\Temp\ipykernel_24232\3175870236.py:11: FutureWarning: The provided callable <built-in function sum> is currently using DataFrameGroupBy.sum. In a future version of pandas, the provided callable will be used directly. To keep current behavior pass the string "sum" instead.
  all_filtered_pivot_gen = all_region_filtered_gen.pivot_table(index='genre', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc=sum)

<Axes: title={'center': 'Top Regional Sales By Genre (NA, EU, JP, & Other)'}, xlabel='genre'>

# Look at top sales in all countries

all_grouped_gen = genre_region.query("genre == @top_genres")
display(all_grouped_gen)

# NA
na_grouped_gen = all_grouped_gen.groupby('genre')['na_sales'].sum()
na_grouped_gen = na_grouped_gen.reset_index()
display(na_grouped)

# JP
jp_grouped_gen = all_grouped_gen.groupby('genre')['jp_sales'].sum()
jp_grouped_gen = jp_grouped_gen.reset_index()
display(jp_grouped_gen)

# EU
eu_grouped_gen = all_grouped_gen.groupby('genre')['eu_sales'].sum()
eu_grouped_gen = eu_grouped_gen.reset_index()
display(eu_grouped_gen)

# Other
other_grouped_gen = all_grouped_gen.groupby('genre')['other_sales'].sum()
other_grouped_gen = other_grouped_gen.reset_index()
display(other_grouped_gen)


# Total
total_grouped_gen = all_grouped_gen.groupby('genre')['total_sales'].sum()
total_grouped_gen = total_grouped_gen.reset_index()
display(total_grouped_gen)


# All
all_top_gen = na_grouped_gen
all_top_gen['jp_sales'] = jp_grouped_gen['jp_sales']
all_top_gen['eu_sales'] = eu_grouped_gen['eu_sales']
all_top_gen['other_sales'] = other_grouped_gen['other_sales']
all_top_gen['total_sales'] = total_grouped_gen['total_sales']
all_top_gen = all_top_gen.sort_values(by='total_sales',ascending=False)
all_top_gen = all_top_gen.reset_index()

display(all_top_gen)

# Percent each region consumes for each of the top Genres
all_top_gen['na_%'] = ((all_top_gen['na_sales'] / all_top_gen['total_sales']) * 100).round(1)
all_top_gen['jp_%'] = ((all_top_gen['jp_sales'] / all_top_gen['total_sales']) * 100).round(1)
all_top_gen['eu_%'] = ((all_top_gen['eu_sales'] / all_top_gen['total_sales']) * 100).round(1)
all_top_gen['other_%'] = ((all_top_gen['other_sales'] / all_top_gen['total_sales']) * 100).round(1)



display(all_top_gen)

# Percent each region consumes for ALL genres
all_gen = all_region_gen_sales.groupby('genre')[['na_sales','jp_sales','eu_sales','other_sales','total_sales']].sum()

na_gen = all_region_gen_sales.groupby('genre')['na_sales'].sum()
na_gen = na_gen.reset_index()
jp_gen = all_region_gen_sales.groupby('genre')['jp_sales'].sum()
jp_gen = jp_gen.reset_index()
eu_gen = all_region_gen_sales.groupby('genre')['eu_sales'].sum()
eu_gen = eu_gen.reset_index()
other_gen = all_region_gen_sales.groupby('genre')['other_sales'].sum()
other_gen = other_gen.reset_index()
total_gen = all_region_gen_sales.groupby('genre')['total_sales'].sum()
total_gen = total_gen.reset_index()

all_gen['na_%'] = ((all_gen['na_sales'] / all_gen['total_sales']) * 100).round(1)
all_gen['jp_%'] = ((all_gen['jp_sales'] / all_gen['total_sales']) * 100).round(1)
all_gen['eu_%'] = ((all_gen['eu_sales'] / all_gen['total_sales']) * 100).round(1)
all_gen['other_%'] = ((all_gen['other_sales'] / all_gen['total_sales']) * 100).round(1)

all_gen = all_gen.reset_index().sort_values(by='total_sales',ascending=False)

display(all_gen)

all_filtered_pivot_gen.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Top Regional Sales By Genre (NA, EU, JP, & Other)",grid=True)

<Axes: title={'center': 'Top Regional Sales By Genre (NA, EU, JP, & Other)'}, xlabel='genre'>

# Function to analyze ESRB rating impact

# Analyze the original data & the updated games_1 data since we changed the ESRB ratings so much
platforms_info_og = games[['platform','year_of_release','genre','na_sales','eu_sales','jp_sales','other_sales','total_sales','user_score','critic_score','rating']]
platforms_info_og_1 =  games_1[['platform','year_of_release','genre','na_sales','eu_sales','jp_sales','other_sales','total_sales','user_score','critic_score','rating']]

# games_3
rating_region = platforms_info[['rating','na_sales','eu_sales','jp_sales','other_sales','total_sales']]
display(platforms_region)

# games_1
rating_region_og_1 = platforms_info_og_1[['rating','na_sales','eu_sales','jp_sales','other_sales','total_sales']]
display(rating_region_og_1)


# games
rating_region_og = platforms_info_og[['rating','na_sales','eu_sales','jp_sales','other_sales','total_sales']]
display(rating_region_og)



# Analyze each region (games_3)
na_region_esrb = rating_region[['rating','na_sales']]
eu_region_esrb = rating_region[['rating','eu_sales']]
jp_region_esrb = rating_region[['rating','jp_sales']]
other_region_esrb = rating_region[['rating','other_sales']]
all_region_esrb = rating_region[['rating','na_sales','eu_sales','jp_sales','other_sales']]
all_region_esrb_sales = rating_region[['rating','na_sales','eu_sales','jp_sales','other_sales','total_sales']]


# Analyze each region (games_1)
na_region_esrb_og_1 = rating_region_og_1[['rating','na_sales']]
eu_region_esrb_og_1 = rating_region_og_1[['rating','eu_sales']]
jp_region_esrb_og_1 = rating_region_og_1[['rating','jp_sales']]
other_region_esrb_og_1 = rating_region_og_1[['rating','other_sales']]
all_region_esrb_og_1 = rating_region_og_1[['rating','na_sales','eu_sales','jp_sales','other_sales']]
all_region_esrb_sales_og_1 = rating_region_og_1[['rating','na_sales','eu_sales','jp_sales','other_sales','total_sales']]



# Analyze each region (games)
na_region_esrb_og = rating_region_og[['rating','na_sales']]
eu_region_esrb_og = rating_region_og[['rating','eu_sales']]
jp_region_esrb_og = rating_region_og[['rating','jp_sales']]
other_region_esrb_og = rating_region_og[['rating','other_sales']]
all_region_esrb_og = rating_region_og[['rating','na_sales','eu_sales','jp_sales','other_sales']]
all_region_esrb_sales_og = rating_region_og[['rating','na_sales','eu_sales','jp_sales','other_sales','total_sales']]



# Analyze NA region

# Make a pivot table for the NA Region

na_pivot_esrb = na_region_esrb.pivot_table(index='rating', values='na_sales',aggfunc='sum')
na_pivot_esrb_og_1 = na_region_esrb_og_1.pivot_table(index='rating', values='na_sales',aggfunc='sum')
na_pivot_esrb_og = na_region_esrb_og.pivot_table(index='rating', values='na_sales',aggfunc='sum')

na_pivot_esrb.plot(kind='bar', figsize=(14,8), colormap = 'Spectral', title="North American Sales By ESRB Rating (Games_3)",grid=True)
na_pivot_esrb_og_1.plot(kind='bar', figsize=(14,8), colormap = 'Spectral', title="North American Sales By ESRB Rating (Games_1)",grid=True)
na_pivot_esrb_og.plot(kind='bar', figsize=(14,8), colormap = 'Spectral', title="North American Sales By ESRB Rating (Games)",grid=True)




# Make a pivot table for the EU Region

eu_pivot_esrb = eu_region_esrb.pivot_table(index='rating', values='eu_sales',aggfunc='sum')
eu_pivot_esrb_og_1 = eu_region_esrb_og_1.pivot_table(index='rating', values='eu_sales',aggfunc='sum')
eu_pivot_esrb_og = eu_region_esrb_og.pivot_table(index='rating', values='eu_sales',aggfunc='sum')

eu_pivot_esrb.plot(kind='bar', figsize=(14,8), colormap = 'inferno_r', title="European Sales By ESRB Rating (Games_3)",grid=True)
eu_pivot_esrb_og_1.plot(kind='bar', figsize=(14,8), colormap = 'inferno_r', title="European Sales By ESRB Rating (Games_1)",grid=True)
eu_pivot_esrb_og.plot(kind='bar', figsize=(14,8), colormap = 'inferno_r', title="European Sales By ESRB Rating (Games)",grid=True)



# Make a pivot table for the JP Region

jp_pivot_esrb = jp_region_esrb.pivot_table(index='rating', values='jp_sales',aggfunc='sum')
jp_pivot_esrb_og_1 = jp_region_esrb_og_1.pivot_table(index='rating', values='jp_sales',aggfunc='sum')
jp_pivot_esrb_og = jp_region_esrb_og.pivot_table(index='rating', values='jp_sales',aggfunc='sum')

jp_pivot_esrb.plot(kind='bar', figsize=(14,8), colormap = 'Accent', title="Japanese Sales By ESRB Rating (Games_3)",grid=True)
jp_pivot_esrb_og_1.plot(kind='bar', figsize=(14,8), colormap = 'Accent', title="Japanese Sales By ESRB Rating (Games_1)",grid=True)
jp_pivot_esrb_og.plot(kind='bar', figsize=(14,8), colormap = 'Accent', title="Japanese Sales By ESRB Rating (Games)",grid=True)


# Make a pivot table for the Other Region


other_pivot_esrb = other_region_esrb.pivot_table(index='rating', values='other_sales',aggfunc='sum')
other_pivot_esrb_og_1 = other_region_esrb_og_1.pivot_table(index='rating', values='other_sales',aggfunc='sum')
other_pivot_esrb_og = other_region_esrb_og.pivot_table(index='rating', values='other_sales',aggfunc='sum')

other_pivot_esrb.plot(kind='bar', figsize=(14,8), colormap = 'copper_r', title="Other Countries Sales By ESRB Rating (NOT NA, EU, or JP) (Games_3)",grid=True)
other_pivot_esrb_og_1.plot(kind='bar', figsize=(14,8), colormap = 'copper_r', title="Other Countries Sales By ESRB Rating (NOT NA, EU, or JP) (Games_1)",grid=True)
other_pivot_esrb_og.plot(kind='bar', figsize=(14,8), colormap = 'copper_r', title="Other Countries Sales By ESRB Rating (NOT NA, EU, or JP) (Games)",grid=True)


# Make a pivot table with all countries

all_pivot_esrb = all_region_esrb.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')
all_pivot_esrb_og_1 = all_region_esrb_og_1.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')
all_pivot_esrb_og = all_region_esrb_og.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')

all_pivot_esrb.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="All Countries Sales By ESRB Rating (NA, EU, JP, & Other) (Games_3)",grid=True)
all_pivot_esrb_og_1.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="All Countries Sales By ESRB Rating (NA, EU, JP, & Other) (Games_1)",grid=True)
all_pivot_esrb_og.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="All Countries Sales By ESRB Rating (NA, EU, JP, & Other) (Games)",grid=True)

<Axes: title={'center': 'All Countries Sales By ESRB Rating (NA, EU, JP, & Other) (Games)'}, xlabel='rating'>

# Analyze ESRB impact for each region
# Create a comparative genre analysis


# Filter out the main ratings
top_rating = ['E', 'T','M','E10+']
all_region_filtered_rate = rating_region.query("rating == @top_rating")[['rating','na_sales','eu_sales','jp_sales','other_sales']]
all_region_filtered_rate_og_1 = rating_region_og_1.query("rating == @top_rating")[['rating','na_sales','eu_sales','jp_sales','other_sales']]

display(all_region_filtered_rate)
display(all_region_filtered_rate_og_1)



# Visualize cross-regional comparison for ratings
all_filtered_pivot_rate = all_region_filtered_rate.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')
all_filtered_pivot_rate_og_1 = all_region_filtered_rate_og_1.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='sum')


all_filtered_pivot_rate.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Top Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_3)",grid=True)
all_filtered_pivot_rate_og_1.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Top Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_1)",grid=True)

<Axes: title={'center': 'Top Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_1)'}, xlabel='rating'>

# Look at ESRB ratings in a chart (Both games_1 & games_3)

all_grouped_rate = rating_region.query("rating == @top_rating")
all_grouped_rate_og_1 = rating_region_og_1.query("rating == @top_rating")


# NA
na_grouped_rate = all_grouped_rate.groupby('rating')['na_sales'].sum()
na_grouped_rate = na_grouped_rate.reset_index()

na_grouped_rate_og_1 = all_grouped_rate_og_1.groupby('rating')['na_sales'].sum()
na_grouped_rate_og_1 = na_grouped_rate_og_1.reset_index()

# JP
jp_grouped_rate = all_grouped_rate.groupby('rating')['jp_sales'].sum()
jp_grouped_rate = jp_grouped_rate.reset_index()

jp_grouped_rate_og_1 = all_grouped_rate_og_1.groupby('rating')['jp_sales'].sum()
jp_grouped_rate_og_1 = jp_grouped_rate_og_1.reset_index()


# EU
eu_grouped_rate = all_grouped_rate.groupby('rating')['eu_sales'].sum()
eu_grouped_rate = eu_grouped_rate.reset_index()

eu_grouped_rate_og_1 = all_grouped_rate_og_1.groupby('rating')['eu_sales'].sum()
eu_grouped_rate_og_1 = eu_grouped_rate_og_1.reset_index()


# Other

other_grouped_rate = all_grouped_rate.groupby('rating')['other_sales'].sum()
other_grouped_rate = other_grouped_rate.reset_index()

other_grouped_rate_og_1 = all_grouped_rate_og_1.groupby('rating')['other_sales'].sum()
other_grouped_rate_og_1 = other_grouped_rate_og_1.reset_index()


# Total
total_grouped_rate = all_grouped_rate.groupby('rating')['total_sales'].sum()
total_grouped_rate = total_grouped_rate.reset_index()

total_grouped_rate_og_1 = all_grouped_rate_og_1.groupby('rating')['total_sales'].sum()
total_grouped_rate_og_1 = total_grouped_rate_og_1.reset_index()





# All (games_3)
all_top_rate = na_grouped_rate
all_top_rate['jp_sales'] = jp_grouped_rate['jp_sales']
all_top_rate['eu_sales'] = eu_grouped_rate['eu_sales']
all_top_rate['other_sales'] = other_grouped_rate['other_sales']
all_top_rate['total_sales'] = total_grouped_rate['total_sales']
all_top_rate = all_top_rate.sort_values(by='total_sales',ascending=False)
all_top_rate = all_top_rate.reset_index()

display(all_top_rate)



# All (games_1)
all_top_rate_og_1 = na_grouped_rate_og_1
all_top_rate_og_1['jp_sales'] = jp_grouped_rate_og_1['jp_sales']
all_top_rate_og_1['eu_sales'] = eu_grouped_rate_og_1['eu_sales']
all_top_rate_og_1['other_sales'] = other_grouped_rate_og_1['other_sales']
all_top_rate_og_1['total_sales'] = total_grouped_rate_og_1['total_sales']
all_top_rate_og_1 = all_top_rate_og_1.sort_values(by='total_sales',ascending=False)
all_top_rate_og_1 = all_top_rate_og_1.reset_index()

display(all_top_rate_og_1)

# Percent each region consumes for main ESRB ratings
all_top_rate['na_%'] = ((all_top_rate['na_sales'] / all_top_rate['total_sales']) * 100).round(1)
all_top_rate['jp_%'] = ((all_top_rate['jp_sales'] / all_top_rate['total_sales']) * 100).round(1)
all_top_rate['eu_%'] = ((all_top_rate['eu_sales'] / all_top_rate['total_sales']) * 100).round(1)
all_top_rate['other_%'] = ((all_top_rate['other_sales'] / all_top_rate['total_sales']) * 100).round(1)

all_top_rate_og_1['na_%'] = ((all_top_rate_og_1['na_sales'] / all_top_rate_og_1['total_sales']) * 100).round(1)
all_top_rate_og_1['jp_%'] = ((all_top_rate_og_1['jp_sales'] / all_top_rate_og_1['total_sales']) * 100).round(1)
all_top_rate_og_1['eu_%'] = ((all_top_rate_og_1['eu_sales'] / all_top_rate_og_1['total_sales']) * 100).round(1)
all_top_rate_og_1['other_%'] = ((all_top_rate_og_1['other_sales'] / all_top_rate_og_1['total_sales']) * 100).round(1)

display(all_top_rate)
display(all_top_rate_og_1)

# Mean data
high_sales = all_region_filtered_rate[(all_region_filtered_rate['na_sales'] >1) | (all_region_filtered_rate['eu_sales']>1) | (all_region_filtered_rate['jp_sales']>1) |(all_region_filtered_rate['other_sales']>1)]
high_sales_og_1 = all_region_filtered_rate_og_1[(all_region_filtered_rate_og_1['na_sales'] >1) | (all_region_filtered_rate_og_1['eu_sales']>1) | (all_region_filtered_rate_og_1['jp_sales']>1) |(all_region_filtered_rate_og_1['other_sales']>1)]
all_region_filtered_rate_high = high_sales.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='mean')
all_region_filtered_rate_high_og_1 = high_sales_og_1.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='mean')
all_region_filtered_rate_high.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Mean High Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_3)",grid=True)
all_region_filtered_rate_high_og_1.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Mean High Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_1)",grid=True,ylim=(0,0.5))


#display(all_region_filtered_rate_high)

all_filtered_pivot_rate_mean = all_region_filtered_rate.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='mean')
all_filtered_pivot_rate_mean_og_1 = all_region_filtered_rate_og_1.pivot_table(index='rating', values=['na_sales','eu_sales','jp_sales','other_sales'],aggfunc='mean')

all_filtered_pivot_rate_mean.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Mean Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_3)",grid=True)
all_filtered_pivot_rate_mean_og_1.plot(kind='bar', figsize=(16,8), colormap = 'jet', title="Mean Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_1)",grid=True)

<Axes: title={'center': 'Mean Regional Sales By ESRB Rating (NA, EU, JP, & Other) (Games_1)'}, xlabel='rating'>

# H0 = Average user ratings of the Xbox One and PC platforms are the same

# Filter out XOne and PC games
xp = platforms_info[platforms_info['platform'].isin(['XOne','PC'])]


# Filter platforms and user_score
xp_user = xp[['platform','user_score']]
xp_user = xp_user.reset_index()


# Group the data, get the mean
xp_user_mean = xp_user.groupby('platform')['user_score'].mean().round(3)
xp_user_mean = xp_user_mean.reset_index()
xp_user_mean['user_mean'] = xp_user_mean['user_score']

# Get the variance
xp_user_var = xp_user.groupby('platform')['user_score'].var().round(3)
xp_user_var = xp_user_var.reset_index()


xp_user_mean['user_var'] = xp_user_var['user_score']
display(xp_user_mean)


# Filter the statistical data
xp_stats = platform_ts_df[platform_ts_df['platform'].isin(['XOne', 'PC'])]
display(xp_stats)

# Filter only XOne data
xone = xp_user[xp_user['platform'] == 'XOne']
xone_user = xone['user_score'].dropna()


# Filter only PC data
pc = xp_user[xp_user['platform'] == 'PC']
pc_user = pc['user_score'].dropna()



# Set the critical significance
alpha = 0.05 


# Test hypothesis: the mean of Xone and PC are equal/same
results = st.ttest_ind(xone_user,pc_user, equal_var=False)

# Print the p-value
print('p-value:',results.pvalue)

# compare the p-value with the significance level
if results.pvalue < alpha:
    print("We reject the null hypothesis")
else:
    print("We can't reject the null hypothesis")

p-value: 4.935072360183449e-06
We reject the null hypothesis

# H0 = Average user ratings for the Action and Sports genres are the same
# H1 = Average user ratings for the Action and Sports genres are different


# Filter out Action and Sports Genres
action = platforms_info[platforms_info['genre'] == 'Action']
action = action[['genre','user_score']]
action = action.dropna()
action_scores = action['user_score']


sports = platforms_info[platforms_info['genre'] == 'Sports']
sports = sports[['genre','user_score']]
sports = sports.dropna()
sports_scores = sports['user_score']


# Get the variance + mean
print("Action User Score Variance:", action_scores.var().round(3))
print("Action User Score Mean:", action_scores.mean().round(3))
print("Sports User Score Variance:", sports_scores.var().round(3))
print("Sports User Score Mean:", sports_scores.mean().round(3))


# Set the critical significance
alpha = 0.05 


# Test hypothesis: the mean of user_scores for Action and Sports genre's are equal/same 
results_gen = st.ttest_ind(action_scores,sports_scores, equal_var=False)

# Print the p-value
print('p-value:',results_gen.pvalue)

# compare the p-value with the significance level
if results_gen.pvalue < alpha:
    print("We reject the null hypothesis")
else:
    print("We can't reject the null hypothesis")

Action User Score Variance: 203.175
Action User Score Mean: 70.54
Sports User Score Variance: 259.693
Sports User Score Mean: 69.625
p-value: 0.12024530426191612
We can't reject the null hypothesis

genre_overall_sales = games_3.groupby('genre')['total_sales'].sum()
genre_overall_sales.sort_values(ascending= False)

genre
Action          1744.17
Sports          1331.26
Shooter         1052.45
Role-Playing     934.56
Platform         827.29
Misc             802.51
Racing           728.67
Fighting         447.53
Simulation       389.97
Puzzle           242.57
Adventure        237.59
Strategy         174.23
Name: total_sales, dtype: float64

platform_overall_mean = games_3.groupby('platform')['total_sales'].mean()
platform_overall_mean.sort_values(ascending=False)

platform
GB      2.606735
NES     2.561735
GEN     1.050000
SNES    0.836987
PS4     0.801378
X360    0.770349
2600    0.729173
PS3     0.706667
Wii     0.687508
N64     0.685517
XOne    0.645020
PS      0.610576
PS2     0.581106
WiiU    0.559116
3DS     0.498077
GBA     0.386679
DS      0.374765
GC      0.357788
XB      0.312791
SCD     0.310000
DC      0.306731
PC      0.266448
PSP     0.243025
WS      0.236667
SAT     0.194162
PSV     0.125744
NG      0.120000
TG16    0.080000
GG      0.040000
3DO     0.033333
PCFX    0.030000
Name: total_sales, dtype: float64

Video Game Sales Analysis Project¶

Project Overview¶

2.2 Data Type Conversion¶

2.3 Handling Missing Values¶

2.4 Calculate Total Sales¶

Questions to Consider:¶

3.2 Platform Sales Analysis Over Time¶

Questions to Consider:¶

3.3 Determining Relevant Time Period¶

Document Your Decision:¶

3.4 Platform Performance Analysis¶

3.5 Sales Distribution Analysis¶

3.6 Review Score Impact Analysis¶

3.7 Cross-Platform Comparison¶

3.8 Genre Analysis¶

Key Questions for Genre Analysis:¶

4.1 Regional Platform Analysis¶

Cross-Regional Platform Comparison¶

4.2 Regional Genre Analysis¶

Cross-Regional Genre Comparison¶

4.3 ESRB Rating Impact Analysis¶

Overall Conclusion:¶

General Conclusion Notes:¶

Missing Data:¶

Release Year Data:¶

Platform Data:¶

Platform Data - Growth Percent:¶

Statistical Information for Platforms:¶

User Score & Critic Score Analysis for X360 Sales¶

Performance Assessment for Games Across Multiple Platforms:¶

Genre Analysis Data:¶

PLATFORM SALES BY REGION:¶

GENRE SALES BY REGION¶

ESRB SALES BY REGION¶

Hypothesis Testing:¶

	Name	Platform	Year_of_Release	Genre	NA_sales	EU_sales	JP_sales	Other_sales	Critic_Score	User_Score	Rating
0	Wii Sports	Wii	2006.0	Sports	41.36	28.96	3.77	8.45	76.0	8	E
1	Super Mario Bros.	NES	1985.0	Platform	29.08	3.58	6.81	0.77	NaN	NaN	NaN
2	Mario Kart Wii	Wii	2008.0	Racing	15.68	12.76	3.79	3.29	82.0	8.3	E
3	Wii Sports Resort	Wii	2009.0	Sports	15.61	10.93	3.28	2.95	80.0	8	E
4	Pokemon Red/Pokemon Blue	GB	1996.0	Role-Playing	11.27	8.89	10.22	1.00	NaN	NaN	NaN

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
183	Madden NFL 2004	PS2	NaN	Sports	4.26	0.26	0.01	0.71	94.0	85.0	E
377	FIFA Soccer 2004	PS2	NaN	Sports	0.59	2.36	0.04	0.51	84.0	64.0	E
456	LEGO Batman: The Videogame	Wii	NaN	Action	1.80	0.97	0.00	0.29	74.0	79.0	E10+
475	wwe Smackdown vs. Raw 2006	PS2	NaN	Fighting	1.57	1.02	0.00	0.41	NaN	NaN	NaN
609	Space Invaders	2600	NaN	Shooter	2.36	0.14	0.00	0.03	NaN	NaN	NaN
627	Rock Band	X360	NaN	Misc	1.93	0.33	0.00	0.21	92.0	82.0	T
657	Frogger's Adventures: Temple of the Frog	GBA	NaN	Adventure	2.15	0.18	0.00	0.07	73.0	NaN	E
678	LEGO Indiana Jones: The Original Adventures	Wii	NaN	Action	1.51	0.61	0.00	0.21	78.0	66.0	E10+
719	Call of Duty 3	Wii	NaN	Shooter	1.17	0.84	0.00	0.23	69.0	67.0	T
805	Rock Band	Wii	NaN	Misc	1.33	0.56	0.00	0.20	80.0	63.0	T
1131	Call of Duty: Black Ops	PC	NaN	Shooter	0.58	0.81	0.00	0.23	81.0	52.0	M
1142	Rock Band	PS3	NaN	Misc	0.99	0.41	0.00	0.22	92.0	84.0	T
1301	Triple Play 99	PS	NaN	Sports	0.81	0.55	0.00	0.10	NaN	NaN	NaN
1506	Adventure	2600	NaN	Adventure	1.21	0.08	0.00	0.01	NaN	NaN	NaN
1538	LEGO Batman: The Videogame	PSP	NaN	Action	0.57	0.44	0.00	0.27	73.0	74.0	E10+
1585	Combat	2600	NaN	Action	1.17	0.07	0.00	0.01	NaN	NaN	NaN
1609	LEGO Harry Potter: Years 5-7	Wii	NaN	Action	0.69	0.42	0.00	0.12	76.0	78.0	E10+
1650	NASCAR Thunder 2003	PS2	NaN	Racing	0.60	0.46	0.00	0.16	84.0	87.0	E
1699	Hitman 2: Silent Assassin	XB	NaN	Action	0.76	0.38	0.00	0.05	84.0	80.0	M
1840	Rock Band	PS2	NaN	Misc	0.71	0.06	0.00	0.35	82.0	68.0	T

	name	platform	year_of_release	genre	na_sales	eu_sales	other_sales	critic_score	user_score	rating
1609	LEGO Harry Potter: Years 5-7	Wii	2012.0	Action	0.69	0.42	0.12	76.0	78.0	E10+
2132	LEGO Harry Potter: Years 5-7	X360	2012.0	Action	0.51	0.37	0.09	77.0	79.0	E10+
2273	LEGO Harry Potter: Years 5-7	PS3	2012.0	Action	0.36	0.41	0.15	76.0	83.0	E10+
3081	LEGO Harry Potter: Years 5-7	DS	2012.0	Action	0.34	0.25	0.07	69.0	NaN	E10+
4818	LEGO Harry Potter: Years 5-7	3DS	2012.0	Action	0.18	0.19	0.03	71.0	65.0	E10+
6476	LEGO Harry Potter: Years 5-7	PSP	2012.0	Action	0.10	0.10	0.06	NaN	NaN	E10+
7210	LEGO Harry Potter: Years 5-7	PC	2012.0	Action	0.05	0.14	0.03	80.0	85.0	E10+
8059	LEGO Harry Potter: Years 5-7	PSV	2012.0	Action	0.07	0.07	0.03	64.0	68.0	E10+

	name	year_of_release
0	Beyblade Burst	2016.0
1	Fire Emblem Fates	2015.0
2	Frozen: Olaf's Quest	2013.0
3	Haikyu!! Cross Team Match!	2016.0
4	Tales of Xillia 2	2012.0
...	...	...
11421	thinkSMART FAMILY!	2010.0
11422	thinkSMART: Chess for Kids	2011.0
11423	uDraw Studio	2010.0
11424	uDraw Studio: Instant Artist	2011.0
11425	¡Shin Chan Flipa en colores!	2007.0

	name	platform	year_of_release_x	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
183	Madden NFL 2004	PS2	2003.0	Sports	4.26	0.26	0.01	0.71	94.0	85.0	E
1881	Madden NFL 2004	XB	2003.0	Sports	1.02	0.02	0.00	0.05	92.0	83.0	E
3889	Madden NFL 2004	GC	2003.0	Sports	0.40	0.10	0.00	0.01	94.0	77.0	E
5708	Madden NFL 2004	GBA	2003.0	Sports	0.22	0.08	0.00	0.01	70.0	66.0	E

	name	platform	year_of_release_x	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
257	Sonic the Hedgehog	GEN	1991.0	Platform	3.03	0.91	0.26	0.13	NaN	NaN	NaN
1745	Sonic the Hedgehog	PS3	2006.0	Platform	0.41	0.06	0.04	0.66	43.0	41.0	E10+
1996	Sonic the Hedgehog	X360	2006.0	Platform	0.44	0.48	0.00	0.11	46.0	44.0	E10+
4127	Sonic the Hedgehog	PS3	2006.0	Platform	0.00	0.48	0.00	0.00	43.0	41.0	E10+

	name	rating
0	Tales of Xillia 2	T
1	.hack//Infection Part 1	T
2	.hack//Mutation Part 2	T
3	.hack//Outbreak Part 3	T
4	007 Racing	T
...	...	...
6061	thinkSMART	E
6062	thinkSMART FAMILY!	E
6063	thinkSMART: Chess for Kids	E
6064	uDraw Studio	E
6065	uDraw Studio: Instant Artist	E

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
253	Need for Speed: Most Wanted	PS2	2005.0	Racing	2.03	1.79	0.08	0.47	82.0	91.0	T
523	Need for Speed: Most Wanted	PS3	2012.0	Racing	0.71	1.46	0.06	0.58	NaN	NaN	T
1190	Need for Speed: Most Wanted	X360	2012.0	Racing	0.62	0.78	0.01	0.15	83.0	85.0	T
1591	Need for Speed: Most Wanted	X360	2005.0	Racing	1.00	0.13	0.02	0.10	83.0	85.0	T
1998	Need for Speed: Most Wanted	XB	2005.0	Racing	0.53	0.46	0.00	0.05	83.0	88.0	T
2048	Need for Speed: Most Wanted	PSV	2012.0	Racing	0.33	0.45	0.01	0.22	NaN	NaN	T
3581	Need for Speed: Most Wanted	GC	2005.0	Racing	0.43	0.11	0.00	0.02	80.0	91.0	T
5972	Need for Speed: Most Wanted	PC	2005.0	Racing	0.02	0.23	0.00	0.04	82.0	85.0	T
6273	Need for Speed: Most Wanted	WiiU	2013.0	Racing	0.13	0.12	0.00	0.02	NaN	NaN	T
6410	Need for Speed: Most Wanted	DS	2005.0	Racing	0.24	0.01	0.00	0.02	45.0	61.0	E
6473	Need for Speed: Most Wanted	GBA	2005.0	Racing	0.19	0.07	0.00	0.00	NaN	83.0	E
11715	Need for Speed: Most Wanted	PC	2012.0	Racing	0.00	0.06	0.00	0.02	82.0	85.0	T

	name	platform	year_of_release	genre	na_sales	eu_sales	other_sales	critic_score	user_score	rating
507	Madden NFL 13	X360	2012.0	Sports	2.53	0.15	0.17	81.0	58.0	E
604	Madden NFL 13	PS3	2012.0	Sports	2.11	0.22	0.23	83.0	55.0	E
3986	Madden NFL 13	Wii	2012.0	Sports	0.47	0.00	0.03	NaN	73.0	E
5887	Madden NFL 13	PSV	2012.0	Sports	0.28	0.00	0.02	63.0	73.0	E
7066	Madden NFL 13	WiiU	2012.0	Sports	0.21	0.00	0.02	75.0	67.0	E
16230	Madden NFL 13	PS3	2012.0	Sports	0.00	0.01	0.00	83.0	55.0	E

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
659	NaN	GEN	1993.0	NaN	1.78	0.53	0.00	0.08	NaN	NaN	NaN
14244	NaN	GEN	1993.0	NaN	0.00	0.00	0.03	0.00	NaN	NaN	NaN

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
323	Call of Duty: Ghosts	PS4	2013.0	Shooter	1.78	1.43	0.05	0.57	78.0	37.0	M
430	Enter the Matrix	PS2	2003.0	Action	1.78	1.12	0.09	0.19	62.0	81.0	T
570	Guitar Hero: World Tour	X360	2008.0	Misc	1.78	0.63	0.00	0.25	85.0	63.0	T
659	NaN	GEN	1993.0	NaN	1.78	0.53	0.00	0.08	NaN	NaN	NaN
739	Rock Band 2	X360	2008.0	Misc	1.78	0.24	0.00	0.18	92.0	83.0	T

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
512	Yoshi's Story	N64	1997.0	Platform	1.29	0.53	0.98	0.05	NaN	NaN	NaN
513	Mortal Kombat	PS3	2011.0	Fighting	1.98	0.53	0.00	0.34	84.0	84.0	M
555	Mario Party	N64	1998.0	Misc	1.25	0.53	0.87	0.05	NaN	NaN	NaN
634	Midnight Club: Los Angeles	PS3	2008.0	Racing	1.56	0.53	0.05	0.31	82.0	82.0	T
659	NaN	GEN	1993.0	NaN	1.78	0.53	0.00	0.08	NaN	NaN	NaN
702	Pokemon Ranger: Shadows of Almia	DS	2008.0	Role-Playing	0.94	0.53	0.62	0.18	68.0	82.0	E
715	Guitar Hero III: Legends of Rock	PS3	2007.0	Misc	1.40	0.53	0.02	0.30	83.0	78.0	T
897	The Legend of Zelda: Oracle of Ages	GB	2001.0	Action	0.92	0.53	0.41	0.06	NaN	NaN	NaN
925	Star Fox Adventures	GC	2002.0	Adventure	0.96	0.53	0.30	0.09	82.0	77.0	T
930	Ratchet & Clank Future: A Crack in Time	PS3	2009.0	Platform	1.05	0.53	0.03	0.26	NaN	NaN	NaN
964	The Orange Box	X360	2007.0	Shooter	1.09	0.53	0.02	0.17	96.0	89.0	M
1014	Crackdown	X360	2007.0	Shooter	1.00	0.53	0.03	0.18	83.0	80.0	M
1174	Mario Party 10	WiiU	2015.0	Misc	0.69	0.53	0.24	0.12	66.0	65.0	E
1180	Watch Dogs	XOne	2014.0	Action	0.90	0.53	0.00	0.14	78.0	58.0	M
1184	Conflict: Desert Storm	PS2	2002.0	Shooter	0.98	0.53	0.00	0.06	55.0	86.0	T
1387	Madden NFL 2002	PS	2001.0	Sports	0.78	0.53	0.00	0.09	88.0	80.0	E
1395	Yoshi's New Island	3DS	2014.0	Platform	0.48	0.53	0.28	0.09	64.0	61.0	E
1405	Sonic Generations	X360	2011.0	Platform	0.71	0.53	0.00	0.13	77.0	83.0	E
1406	Dave Mirra Freestyle BMX 2	PS2	2001.0	Sports	0.67	0.53	0.00	0.18	81.0	81.0	T
1594	Tom Clancy's Rainbow Six: Vegas	PS3	2007.0	Shooter	0.47	0.53	0.03	0.22	86.0	76.0	M
2095	Pro Evolution Soccer 2008	PSP	2008.0	Sports	0.02	0.53	0.19	0.25	80.0	68.0	E
2204	Rise of the Tomb Raider	PS4	2016.0	Adventure	0.23	0.53	0.04	0.14	NaN	NaN	M
2237	Assassin's Creed III	PC	2012.0	Action	0.28	0.53	0.00	0.12	80.0	62.0	M
2829	Total War: Rome II	PC	2013.0	Strategy	0.12	0.53	0.00	0.07	76.0	42.0	T
2859	Battlefield: Bad Company 2	PC	2010.0	Shooter	0.19	0.53	0.00	0.00	87.0	83.0	M
3062	Napoleon: Total War	PC	2010.0	Strategy	0.02	0.53	0.00	0.12	81.0	79.0	T
3388	Dead Space	PC	2008.0	Action	0.00	0.53	0.00	0.06	86.0	80.0	M

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
141	Kinect Sports	X360	2010.0	Sports	3.92	1.73	0.03	0.51	73.0	74.0	E10+
176	Assassin's Creed III	X360	2012.0	Action	3.13	1.69	0.03	0.44	84.0	67.0	M
190	FIFA Soccer 13	X360	2012.0	Action	1.09	3.47	0.03	0.57	90.0	61.0	E
242	Halo 5: Guardians	XOne	2015.0	Shooter	2.78	1.27	0.03	0.41	84.0	64.0	T
243	Spider-Man: The Movie	PS2	2002.0	Action	2.71	1.51	0.03	0.23	76.0	79.0	E
...	...	...	...	...	...	...	...	...	...	...	...
14983	Beyblade Burst	3DS	2016.0	Role-Playing	0.00	0.00	0.03	0.00	NaN	NaN	NaN
14986	Gakuen Alice: WakuWaku * Happy Friends	DS	2007.0	Adventure	0.00	0.00	0.03	0.00	NaN	NaN	NaN
14988	Kyokugen Dasshutsu ADV: Zennin Shiboudesu	PSV	2012.0	Adventure	0.00	0.00	0.03	0.00	NaN	NaN	NaN
14989	Konohana 2: Todoke Kanai Requiem	PS2	2002.0	Adventure	0.00	0.00	0.03	0.00	NaN	NaN	NaN
14990	Derby Time 2006	PSP	2006.0	Sports	0.00	0.00	0.03	0.00	NaN	NaN	NaN

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
78	Halo 2	XB	2004.0	Shooter	6.82	1.53	0.05	0.08	95.0	82.0	M
89	Pac-Man	2600	1982.0	Puzzle	7.28	0.45	0.00	0.08	NaN	NaN	NaN
238	Madden NFL 2005	PS2	2004.0	Sports	4.18	0.26	0.01	0.08	91.0	79.0	E
252	Zelda II: The Adventure of Link	NES	1987.0	Adventure	2.19	0.50	1.61	0.08	NaN	NaN	NaN
372	Donkey Kong Country 3: Dixie Kong's Double Tro...	SNES	1996.0	Platform	1.17	0.50	1.75	0.08	NaN	NaN	NaN
...	...	...	...	...	...	...	...	...	...	...	...
5964	Invizimals: Shadow Zone	PSP	2010.0	Strategy	0.05	0.16	0.00	0.08	NaN	90.0	E10+
6372	Scooby-Doo! and the Spooky Swamp	PS2	2010.0	Action	0.08	0.11	0.00	0.08	NaN	NaN	NaN
6593	Star Wars The Clone Wars: Republic Heroes	PS2	2009.0	Action	0.17	0.01	0.00	0.08	NaN	83.0	T
7893	Monsters vs. Aliens	PS2	2009.0	Action	0.11	0.00	0.00	0.08	64.0	NaN	E10+
8784	The Secret Saturdays: Beasts of the 5th Sun	PS2	2009.0	Action	0.05	0.02	0.00	0.08	NaN	NaN	E10+

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
960	Sonic & Knuckles	GEN	1994.0	Platform	1.24	0.43	0.03	0.12	NaN	NaN	NaN
1365	Disney's The Lion King	GEN	1994.0	Platform	0.97	0.37	0.03	0.05	NaN	NaN	NaN
14244	NaN	GEN	1993.0	NaN	0.00	0.00	0.03	0.00	NaN	NaN	NaN
14488	Puzzle & Action: Tant-R	GEN	1994.0	Misc	0.00	0.00	0.03	0.00	NaN	NaN	NaN

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
145	Sonic the Hedgehog 2	GEN	1992.0	Platform	4.47	1.20	0.16	0.19	NaN	NaN	NaN
257	Sonic the Hedgehog	GEN	1991.0	Platform	3.03	0.91	0.26	0.13	NaN	NaN	E10+
564	Mortal Kombat	GEN	1992.0	Fighting	1.95	0.63	0.00	0.09	NaN	NaN	M
588	Streets of Rage	GEN	1990.0	Action	1.86	0.55	0.11	0.08	NaN	NaN	NaN
659	NaN	GEN	1993.0	NaN	1.78	0.53	0.00	0.08	NaN	NaN	NaN
832	NBA Jam	GEN	1992.0	Sports	1.75	0.25	0.00	0.05	NaN	NaN	E
960	Sonic & Knuckles	GEN	1994.0	Platform	1.24	0.43	0.03	0.12	NaN	NaN	NaN
996	Sonic the Hedgehog 3	GEN	1994.0	Platform	1.02	0.47	0.20	0.07	NaN	NaN	NaN
1099	Street Fighter II': Special Champion Edition	GEN	1992.0	Fighting	1.00	0.30	0.31	0.04	NaN	NaN	NaN
1365	Disney's The Lion King	GEN	1994.0	Platform	0.97	0.37	0.03	0.05	NaN	NaN	NaN
1453	Mortal Kombat 3	GEN	1994.0	Fighting	1.03	0.27	0.00	0.04	NaN	NaN	NaN
1842	NBA Jam Tournament Edition	GEN	1994.0	Sports	0.95	0.14	0.00	0.03	NaN	NaN	NaN
6451	Virtua Racing	GEN	1994.0	Racing	0.00	0.00	0.26	0.00	NaN	NaN	NaN
7885	Shining Force II	GEN	1993.0	Strategy	0.00	0.00	0.19	0.00	NaN	NaN	NaN
8893	Super Street Fighter II	GEN	1993.0	Fighting	0.00	0.00	0.15	0.00	NaN	NaN	NaN
9000	Lunar 2: Eternal Blue(sales, but wrong system)	GEN	1994.0	Role-Playing	0.00	0.00	0.14	0.00	NaN	NaN	NaN
9563	Gunstar Heroes	GEN	1992.0	Shooter	0.00	0.00	0.13	0.00	NaN	NaN	NaN
9787	Ecco the Dolphin	GEN	1992.0	Adventure	0.00	0.00	0.12	0.00	NaN	NaN	NaN
11563	Yuu Yuu Hakusho: Makyo Toitsusen	GEN	1994.0	Fighting	0.00	0.00	0.08	0.00	NaN	NaN	NaN
11660	Dragon Slayer: The Legend of Heroes	GEN	1994.0	Role-Playing	0.00	0.00	0.08	0.00	NaN	NaN	NaN
11986	Ecco: The Tides of Time	GEN	1993.0	Adventure	0.00	0.00	0.07	0.00	NaN	NaN	NaN
12098	Street Fighter II': Special Champion Edition (...	GEN	1993.0	Action	0.00	0.00	0.07	0.00	NaN	NaN	NaN
12264	Streets of Rage 3	GEN	1993.0	Action	0.00	0.00	0.07	0.00	NaN	NaN	NaN
12984	Dynamite Headdy	GEN	1993.0	Platform	0.00	0.00	0.05	0.00	NaN	NaN	NaN
13343	Beyond Oasis	GEN	1993.0	Role-Playing	0.00	0.00	0.05	0.00	NaN	NaN	NaN
14085	J-League Pro Striker 2	GEN	1994.0	Sports	0.00	0.00	0.04	0.00	NaN	NaN	NaN
14132	Castlevania Bloodlines	GEN	1994.0	Platform	0.00	0.00	0.04	0.00	NaN	NaN	NaN
14244	NaN	GEN	1993.0	NaN	0.00	0.00	0.03	0.00	NaN	NaN	NaN
14488	Puzzle & Action: Tant-R	GEN	1994.0	Misc	0.00	0.00	0.03	0.00	NaN	NaN	NaN

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating
56	Super Mario All-Stars	SNES	1993.0	Platform	5.99	2.15	2.12	0.29	NaN	NaN	NaN
476	Star Fox	SNES	1993.0	Shooter	1.61	0.51	0.80	0.07	NaN	NaN	NaN
659	NaN	GEN	1993.0	NaN	1.78	0.53	0.00	0.08	NaN	NaN	NaN
852	Super Street Fighter II	SNES	1993.0	Fighting	0.52	0.16	1.29	0.03	NaN	NaN	NaN
892	Mortal Kombat II	SNES	1993.0	Fighting	1.48	0.39	0.00	0.06	NaN	NaN	NaN
...	...	...	...	...	...	...	...	...	...	...	...
12997	Pachinko Wars II	SNES	1993.0	Misc	0.00	0.00	0.05	0.00	NaN	NaN	NaN
13189	Keiba Eight Special	SNES	1993.0	Sports	0.00	0.00	0.05	0.00	NaN	NaN	NaN
13343	Beyond Oasis	GEN	1993.0	Role-Playing	0.00	0.00	0.05	0.00	NaN	NaN	NaN
14244	NaN	GEN	1993.0	NaN	0.00	0.00	0.03	0.00	NaN	NaN	NaN
16207	Rock N' Roll Racing	SNES	1993.0	Racing	0.00	0.00	0.01	0.00	NaN	NaN	NaN

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group
16676	G1 Jockey 4 2008	PS3	2008.0	Sports	0.0	0.0	0.0	0.0	NaN	NaN	NaN	0.0	NaN	NaN	No Sale
16709	SCORE International Baja 1000: The Official Game	PS2	2008.0	Racing	0.0	0.0	0.0	0.0	NaN	NaN	NaN	0.0	NaN	NaN	No Sale

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group
108	Pokemon Sun/Moon	3DS	2016.0	Role-Playing	2.98	1.45	2.26	0.45	NaN	NaN	NaN	7.14	tbd	tbd	5 million - < 10 million
1216	Ratchet & Clank (2016)	PS4	2016.0	Platform	0.50	0.76	0.04	0.24	NaN	NaN	NaN	1.54	tbd	tbd	1 million - < 5 million
1275	Doom (2016)	PS4	2016.0	Shooter	0.54	0.69	0.02	0.24	NaN	NaN	NaN	1.49	tbd	tbd	1 million - < 5 million
1466	Yokai Watch 3	3DS	2016.0	Action	0.00	0.00	1.33	0.00	NaN	NaN	NaN	1.33	tbd	tbd	1 million - < 5 million
1475	The Elder Scrolls V: Skyrim	PS4	2016.0	Role-Playing	0.48	0.59	0.04	0.21	NaN	NaN	M	1.32	tbd	tbd	1 million - < 5 million
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
16699	The Longest 5 Minutes	PSV	2016.0	Action	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000
16703	Strawberry Nauts	PSV	2016.0	Adventure	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000
16710	Samurai Warriors: Sanada Maru	PS3	2016.0	Action	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000
16712	Haitaka no Psychedelica	PSV	2016.0	Adventure	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000
16714	Winning Post 8 2016	PSV	2016.0	Simulation	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group
12966	Touch 'N' Play Collection	DS	2010.0	Misc	0.03	0.01	0.00	0.0	NaN	NaN	E	0.04	NaN	NaN	< 50,000
13001	PAC-MAN and the Ghostly Adventures	WiiU	2013.0	Platform	0.03	0.01	0.00	0.0	58.0	65.0	E10+	0.04	low	medium	< 50,000
13004	Virtua Striker 2002	GC	2002.0	Sports	0.01	0.00	0.03	0.0	58.0	60.0	E	0.04	low	low	< 50,000
13016	Hunted: The Demon's Forge	PC	2011.0	Action	0.03	0.01	0.00	0.0	61.0	66.0	M	0.04	low	medium	< 50,000
13094	Nanostray 2	DS	2008.0	Shooter	0.03	0.01	0.00	0.0	75.0	78.0	E	0.04	medium	high	< 50,000
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
16710	Samurai Warriors: Sanada Maru	PS3	2016.0	Action	0.00	0.00	0.01	0.0	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000
16711	LMA Manager 2007	X360	2006.0	Sports	0.00	0.01	0.00	0.0	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000
16712	Haitaka no Psychedelica	PSV	2016.0	Adventure	0.00	0.00	0.01	0.0	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000
16713	Spirits & Spells	GBA	2003.0	Platform	0.01	0.00	0.00	0.0	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000
16714	Winning Post 8 2016	PSV	2016.0	Simulation	0.00	0.00	0.01	0.0	NaN	NaN	NaN	0.01	tbd	tbd	< 50,000

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
7584	WRC: FIA World Rally Championship	PS3	2005.0	Racing	0.00	0.14	0.01	0.04	68.0	45.0	E	0.19	medium	low	100,000 - < 200,000	2000's
9827	WRC: FIA World Rally Championship	X360	2005.0	Racing	0.00	0.10	0.00	0.02	66.0	60.0	E10+	0.12	medium	low	100,000 - < 200,000	2000's
14233	WRC: FIA World Rally Championship	PSP	2005.0	Racing	0.02	0.01	0.00	0.00	67.0	78.0	E	0.03	medium	high	< 50,000	2000's
16180	WRC: FIA World Rally Championship	PC	2005.0	Racing	0.00	0.01	0.00	0.00	65.0	NaN	RP	0.01	medium	NaN	< 50,000	2000's

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
17	Grand Theft Auto: San Andreas	PS2	2004.0	Action	9.43	0.40	0.41	10.57	95.0	90.0	M	20.81	very high	very high	10 million +	2000's
875	Grand Theft Auto: San Andreas	XB	2005.0	Action	1.26	0.61	0.00	0.09	93.0	86.0	M	1.96	very high	very high	1 million - < 5 million	2000's
2115	Grand Theft Auto: San Andreas	PC	2005.0	Action	0.00	0.93	0.00	0.04	93.0	89.0	M	0.97	very high	very high	500,000 - < 1 million	2000's
10311	Grand Theft Auto: San Andreas	X360	2008.0	Action	0.08	0.02	0.00	0.01	NaN	75.0	M	0.11	NaN	medium	100,000 - < 200,000	2000's

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
340	Friend Collection	DS	2009.0	Misc	0.00	0.00	3.67	0.00	NaN	NaN	NaN	3.67	NaN	NaN	1 million - < 5 million	2000's
403	English Training: Have Fun Improving Your Skills!	DS	2006.0	Misc	0.00	0.99	2.32	0.02	NaN	NaN	NaN	3.33	NaN	NaN	1 million - < 5 million	2000's
1046	Kanshuu Nippon Joushikiryoku Kentei Kyoukai: I...	DS	2006.0	Misc	0.00	0.00	1.71	0.00	NaN	NaN	NaN	1.71	NaN	NaN	1 million - < 5 million	2000's
1187	High School Musical 3: Senior Year	DS	2008.0	Misc	0.63	0.76	0.00	0.17	NaN	NaN	NaN	1.56	NaN	NaN	1 million - < 5 million	2000's
1769	High School Musical 2: Work This Out!	DS	2008.0	Misc	0.50	0.52	0.00	0.13	NaN	NaN	NaN	1.15	NaN	NaN	1 million - < 5 million	2000's
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
16432	Nakayoshi All-Stars: Mezase Gakuen Idol	DS	2008.0	Misc	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000	2000's
16480	Nova Usagi no Game de Ryuugaku!? DS	DS	2007.0	Misc	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000	2000's
16557	Juggler DS	DS	2008.0	Misc	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000	2000's
16592	Who Wants to be a Millionaire: 2nd Edition	DS	2008.0	Misc	0.00	0.01	0.00	0.00	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000	2000's
16632	Style Book: Cinnamoroll	DS	2006.0	Misc	0.00	0.00	0.01	0.00	NaN	NaN	NaN	0.01	NaN	NaN	< 50,000	2000's

	name	platform	year_of_release	genre	eu_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
13672	Clockwork Empires	PC	NaN	Strategy	0.04	0.00	58.0	38.0	RP	0.04	low	low	< 50,000	None
14270	Supreme Ruler: Cold War	PC	2011.0	Strategy	0.03	0.01	63.0	68.0	RP	0.04	low	medium	< 50,000	2010's
16180	WRC: FIA World Rally Championship	PC	2005.0	Racing	0.01	0.00	65.0	NaN	RP	0.01	medium	NaN	< 50,000	2000's

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
2054	Monster Rancher	PS	1997.0	Simulation	0.12	0.08	0.74	0.07	86.0	83.0	NaN	1.01	very high	high	1 million - < 5 million	90's
822	R4: Ridge Racer Type 4	PS	1998.0	Racing	0.68	0.46	0.79	0.13	88.0	92.0	NaN	2.06	very high	very high	1 million - < 5 million	90's
6631	WipEout XL	PS	1996.0	Racing	0.14	0.10	0.00	0.02	93.0	87.0	NaN	0.26	very high	very high	200,000 - < 500,000	90's

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
10110	ECW Anarchy Rulz	PS	1999.0	Fighting	0.06	0.04	0.00	0.01	43.0	63.0	E	0.11	low	low	100,000 - < 200,000	90's
8389	Clock Tower II: The Struggle Within	PS	1998.0	Adventure	0.02	0.01	0.12	0.01	49.0	57.0	M	0.16	low	low	100,000 - < 200,000	90's
10386	Digimon Digital Card Battle	PS	1999.0	Strategy	0.06	0.04	0.00	0.01	51.0	90.0	T	0.11	low	very high	100,000 - < 200,000	90's
12124	Dragon Valor	PS	1999.0	Role-Playing	0.04	0.03	0.00	0.00	57.0	83.0	T	0.07	low	high	50,000 - < 100,000	90's
6993	Gundam Battle Assault	PS	1998.0	Fighting	0.13	0.09	0.00	0.02	61.0	78.0	T	0.24	low	high	200,000 - < 500,000	90's
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
146	Metal Gear Solid	PS	1998.0	Action	3.18	1.83	0.78	0.24	94.0	94.0	M	6.03	very high	very high	5 million - < 10 million	90's
52	Gran Turismo	PS	1997.0	Racing	4.02	3.87	2.54	0.52	96.0	87.0	E	10.95	very high	very high	10 million +	90's
106	Tekken 3	PS	1998.0	Fighting	3.27	2.22	1.40	0.29	96.0	91.0	T	7.18	very high	very high	5 million - < 10 million	90's
284	Half-Life	PC	1997.0	Shooter	4.03	0.00	0.09	0.00	96.0	91.0	M	4.12	very high	very high	1 million - < 5 million	90's
5350	SoulCalibur	DC	1999.0	Fighting	0.00	0.00	0.34	0.00	98.0	88.0	T	0.34	very high	very high	200,000 - < 500,000	90's

	name	platform	year_of_release	genre	na_sales	eu_sales	jp_sales	other_sales	critic_score	user_score	rating	total_sales	critic_score_group	user_score_group	total_sales_group	era
65	Final Fantasy VII	PS	1997.0	Role-Playing	3.01	2.47	3.28	0.96	92.0	92.0	T	9.72	very high	very high	5 million - < 10 million	90's
67	Gran Turismo 2	PS	1999.0	Racing	3.88	3.42	1.69	0.50	93.0	90.0	T	9.49	very high	very high	5 million - < 10 million	90's
88	Final Fantasy VIII	PS	1999.0	Role-Playing	2.28	1.72	3.63	0.23	90.0	86.0	T	7.86	very high	very high	5 million - < 10 million	90's
106	Tekken 3	PS	1998.0	Fighting	3.27	2.22	1.40	0.29	96.0	91.0	T	7.18	very high	very high	5 million - < 10 million	90's
139	Driver	PS	1999.0	Action	3.11	2.80	0.02	0.33	87.0	81.0	T	6.26	very high	high	5 million - < 10 million	90's
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
12124	Dragon Valor	PS	1999.0	Role-Playing	0.04	0.03	0.00	0.00	57.0	83.0	T	0.07	low	high	50,000 - < 100,000	90's
12833	Elemental Gearbolt	PS	1997.0	Shooter	0.03	0.02	0.00	0.00	76.0	NaN	T	0.05	high	NaN	50,000 - < 100,000	90's
13336	StarCraft	PC	1998.0	Strategy	0.00	0.04	0.00	0.01	88.0	91.0	T	0.05	very high	very high	50,000 - < 100,000	90's
14212	Planescape: Torment	PC	1998.0	Role-Playing	0.01	0.02	0.00	0.00	91.0	92.0	T	0.03	very high	very high	< 50,000	90's
15581	You Don't Know Jack	PC	1995.0	Misc	0.02	0.00	0.00	0.00	NaN	NaN	T	0.02	NaN	NaN	< 50,000	90's

	critic_score	user_score	total_sales
genre
Platform	NaN	NaN	4.33
Role-Playing	NaN	NaN	1.52
Simulation	NaN	NaN	1.13
Strategy	NaN	NaN	0.60

	critic_score	user_score	total_sales
genre
Action	88.83	89.86	2.58
Shooter	90.50	86.50	1.41
Fighting	NaN	NaN	1.34
Role-Playing	84.67	88.67	1.22
Adventure	60.33	73.00	0.07
Strategy	NaN	NaN	0.06

	critic_score	user_score	total_sales
genre
Sports	92.00	92.00	5.02
Racing	93.00	90.00	3.84
Action	75.50	81.86	2.28
Fighting	84.12	82.38	1.93
Role-Playing	82.71	86.21	1.80
Platform	88.67	91.67	1.17
Shooter	84.00	86.00	0.98
Adventure	88.00	94.00	0.72
Simulation	82.50	83.00	0.62
Misc	NaN	NaN	0.21
Strategy	73.25	86.25	0.08